All Classes Interface Summary Class Summary Enum Summary Exception Summary
| Class |
Description |
| Abs |
Computes the absolute value of a number.
|
| Acos |
Computes the arccosine of a value.
|
| Acosh |
Computes the inverse hyperbolic cosine.
|
| Adapt |
Simple, one-way adapters for types and terms
|
| Adapter<T1,T2,V1,V2> |
A two-level bidirectional encoder which adapts types to types and terms to terms
|
| AdapterContext |
An evaluation context together with a source language and a target language
|
| Adapters |
Convenience functions for working with Hydra adapters.
|
| Add |
Performs addition on two numbers.
|
| AdditionalBound |
|
| AdditiveExpression |
|
| AdditiveExpression_Binary |
|
| AdditiveExpression.Minus |
|
| AdditiveExpression.PartialVisitor<R> |
|
| AdditiveExpression.Plus |
|
| AdditiveExpression.Unary |
|
| AdditiveExpression.Visitor<R> |
|
| AddOrSubtractExpression |
|
| AddOrSubtractOperator |
|
| AddOrSubtractOperator.Add |
|
| AddOrSubtractOperator.PartialVisitor<R> |
|
| AddOrSubtractOperator.Subtract |
|
| AddOrSubtractOperator.Visitor<R> |
|
| AddOrSubtractRightHandSide |
|
| AdjacentEdge |
|
| AdjacentEdge<V> |
An edge which is adjacent to a given vertex.
|
| AggregateFunctionFeatures |
Aggregate functions
|
| AggregationQuery |
|
| AggregationQuery.Count |
|
| AggregationQuery.PartialVisitor<R> |
|
| AggregationQuery.Visitor<R> |
|
| Aliases |
Aliases and context for Java code generation
|
| AlphaConversionTestCase |
A test case which performs alpha conversion (variable renaming) on a term and compares the result with the expected term
|
| Alter |
Modifies a key's value.
|
| Alternative |
A pattern-matching alternative
|
| AmbiguousName |
|
| And |
Performs logical AND on two boolean values.
|
| AndExpression |
|
| AndExpression |
|
| AndExpression |
Logical and: (and expr1 expr2 ...)
|
| AnnotatedIdentifier |
|
| AnnotatedRhs |
|
| AnnotatedRhs.PartialVisitor<R> |
|
| AnnotatedRhs.Star |
|
| AnnotatedRhs.Visitor<R> |
|
| AnnotatedRhs.Yield |
|
| AnnotatedStatement |
|
| AnnotatedTerm |
A term together with an annotation
|
| AnnotatedType |
A type together with an annotation
|
| Annotation |
|
| Annotation |
|
| Annotation |
|
| Annotation |
|
| Annotation_Alts |
|
| Annotation_Alts.Iri |
|
| Annotation_Alts.Literal |
|
| Annotation_Alts.PartialVisitor<R> |
|
| Annotation_Alts.Visitor<R> |
|
| Annotation.Marker |
|
| Annotation.Normal |
|
| Annotation.PartialVisitor<R> |
|
| Annotation.SingleElement |
|
| Annotation.Visitor<R> |
|
| AnnotationAssertion |
|
| AnnotationAxiom |
|
| AnnotationAxiom.AnnotationAssertion |
|
| AnnotationAxiom.AnnotationPropertyDomain |
|
| AnnotationAxiom.AnnotationPropertyRange |
|
| AnnotationAxiom.PartialVisitor<R> |
|
| AnnotationAxiom.SubAnnotationPropertyOf |
|
| AnnotationAxiom.Visitor<R> |
|
| AnnotationProperty |
|
| AnnotationPropertyDomain |
|
| AnnotationPropertyRange |
|
| Annotations |
Utilities for reading and writing type and term annotations
|
| AnnotationSchema |
Configurable annotation keys for property graph mapping specifications
|
| AnnotationSubject |
|
| AnnotationSubject.AnonymousIndividual |
|
| AnnotationSubject.Iri |
|
| AnnotationSubject.PartialVisitor<R> |
|
| AnnotationSubject.Visitor<R> |
|
| AnnotationTypeBody |
|
| AnnotationTypeDeclaration |
|
| AnnotationTypeElementDeclaration |
|
| AnnotationTypeElementModifier |
|
| AnnotationTypeElementModifier.Abstract |
|
| AnnotationTypeElementModifier.PartialVisitor<R> |
|
| AnnotationTypeElementModifier.Public |
|
| AnnotationTypeElementModifier.Visitor<R> |
|
| AnnotationTypeMemberDeclaration |
|
| AnnotationTypeMemberDeclaration.AnnotationType |
|
| AnnotationTypeMemberDeclaration.Class_ |
|
| AnnotationTypeMemberDeclaration.Constant |
|
| AnnotationTypeMemberDeclaration.Interface |
|
| AnnotationTypeMemberDeclaration.PartialVisitor<R> |
|
| AnnotationTypeMemberDeclaration.Visitor<R> |
|
| AnnotationValue |
|
| AnnotationValue.AnonymousIndividual |
|
| AnnotationValue.Iri |
|
| AnnotationValue.Literal |
|
| AnnotationValue.PartialVisitor<R> |
|
| AnnotationValue.Visitor<R> |
|
| AnonymousIndividual |
|
| AnonymousPatternPart |
|
| AnySimpleType |
|
| AnyType |
|
| AnyURI |
|
| Application |
A term which applies a function to an argument
|
| Application |
Function application: (function arg1 arg2 ...)
|
| ApplicationDeclarationHead |
An application-style declaration head
|
| ApplicationExpression |
An application expression
|
| ApplicationPattern |
An application pattern
|
| ApplicationQuery |
|
| ApplicationType |
The type-level analog of an application term
|
| ApplicationType |
An application type
|
| Apply |
Applies a function in a flow context.
|
| Apply |
Applies a function in a flow context.
|
| Args |
|
| ArithmeticFeatures |
Arithmetic operations
|
| Arity |
Functions dealing with arguments and arity.
|
| ArrayAccess |
|
| ArrayAccess_Variant |
|
| ArrayAccess_Variant.Name |
|
| ArrayAccess_Variant.PartialVisitor<R> |
|
| ArrayAccess_Variant.Primary |
|
| ArrayAccess_Variant.Visitor<R> |
|
| ArrayCreationExpression |
|
| ArrayCreationExpression_ClassOrInterface |
|
| ArrayCreationExpression_ClassOrInterfaceArray |
|
| ArrayCreationExpression_Primitive |
|
| ArrayCreationExpression_PrimitiveArray |
|
| ArrayCreationExpression.ClassOrInterface |
|
| ArrayCreationExpression.ClassOrInterfaceArray |
|
| ArrayCreationExpression.PartialVisitor<R> |
|
| ArrayCreationExpression.Primitive |
|
| ArrayCreationExpression.PrimitiveArray |
|
| ArrayCreationExpression.Visitor<R> |
|
| ArrayInitializer |
|
| ArrayType |
|
| ArrayType_Variant |
|
| ArrayType_Variant.ClassOrInterface |
|
| ArrayType_Variant.PartialVisitor<R> |
|
| ArrayType_Variant.Primitive |
|
| ArrayType_Variant.Variable |
|
| ArrayType_Variant.Visitor<R> |
|
| Asin |
Computes the arcsine of a value.
|
| Asinh |
Computes the inverse hyperbolic sine.
|
| AsPattern |
An 'as' pattern
|
| AsPattern |
|
| Assertion |
A type assertion
|
| Assertion |
|
| Assertion.Class_ |
A class assertion
|
| Assertion.ClassAssertion |
|
| Assertion.DataPropertyAssertion |
|
| Assertion.DifferentIndividuals |
|
| Assertion.NegativeDataPropertyAssertion |
|
| Assertion.NegativeObjectPropertyAssertion |
|
| Assertion.ObjectPropertyAssertion |
|
| Assertion.PartialVisitor<R> |
|
| Assertion.PartialVisitor<R> |
|
| Assertion.SameIndividual |
|
| Assertion.Tuple |
A tuple of assertions
|
| Assertion.Visitor<R> |
|
| Assertion.Visitor<R> |
|
| AssertStatement |
|
| AssertStatement |
|
| AssertStatement_Pair |
|
| AssertStatement.Pair |
|
| AssertStatement.PartialVisitor<R> |
|
| AssertStatement.Single |
|
| AssertStatement.Visitor<R> |
|
| Assignment |
|
| Assignment |
|
| Assignment.Aug |
|
| Assignment.PartialVisitor<R> |
|
| Assignment.Typed |
|
| Assignment.Untyped |
|
| Assignment.Visitor<R> |
|
| AssignmentExpression |
|
| AssignmentExpression |
|
| AssignmentExpression.Assignment |
|
| AssignmentExpression.Conditional |
|
| AssignmentExpression.PartialVisitor<R> |
|
| AssignmentExpression.Visitor<R> |
|
| AssignmentOperator |
|
| AssignmentOperator.And |
|
| AssignmentOperator.Div |
|
| AssignmentOperator.Minus |
|
| AssignmentOperator.Mod |
|
| AssignmentOperator.Or |
|
| AssignmentOperator.PartialVisitor<R> |
|
| AssignmentOperator.Plus |
|
| AssignmentOperator.ShiftLeft |
|
| AssignmentOperator.ShiftRight |
|
| AssignmentOperator.ShiftRightZeroFill |
|
| AssignmentOperator.Simple |
|
| AssignmentOperator.Times |
|
| AssignmentOperator.Visitor<R> |
|
| AssignmentOperator.Xor |
|
| AssociativeExpression |
|
| Associativity |
Operator associativity
|
| Associativity.Both |
|
| Associativity.Left |
|
| Associativity.None |
|
| Associativity.PartialVisitor<R> |
|
| Associativity.Right |
|
| Associativity.Visitor<R> |
|
| Ast |
Term decoders for hydra.ast
|
| Ast |
DSL functions for hydra.ast
|
| Ast |
Term encoders for hydra.ast
|
| AsymmetricObjectProperty |
|
| At |
Gets the element at the specified index of a list.
|
| Atan |
Computes the arctangent of a value.
|
| Atan2 |
Computes the arctangent of y/x.
|
| Atanh |
Computes the inverse hyperbolic tangent.
|
| Atom |
|
| Atom |
|
| Atom.Case |
|
| Atom.CountStar |
|
| Atom.Dict |
|
| Atom.Dictcomp |
|
| Atom.Ellipsis |
|
| Atom.ExistentialSubquery |
|
| Atom.False |
|
| Atom.FunctionInvocation |
|
| Atom.Genexp |
|
| Atom.Group |
|
| Atom.List |
|
| Atom.Listcomp |
|
| Atom.ListComprehension |
|
| Atom.Literal |
|
| Atom.Name |
|
| Atom.None |
|
| Atom.Number_ |
|
| Atom.Parameter |
|
| Atom.Parenthesized |
|
| Atom.PartialVisitor<R> |
|
| Atom.PartialVisitor<R> |
|
| Atom.PatternComprehension |
|
| Atom.PatternPredicate |
|
| Atom.Quantifier |
|
| Atom.Set |
|
| Atom.Setcomp |
|
| Atom.String_ |
|
| Atom.True |
|
| Atom.Tuple |
|
| Atom.Variable |
|
| Atom.Visitor<R> |
|
| Atom.Visitor<R> |
|
| AtomFeatures |
Various kinds of atomic expressions
|
| AtpNameLn |
|
| AtpNameNs |
|
| Attribute |
|
| AugAssign |
|
| AugAssign.AmpersandEqual |
|
| AugAssign.AtEqual |
|
| AugAssign.BarEqual |
|
| AugAssign.CaretEqual |
|
| AugAssign.DoubleSlashEqual |
|
| AugAssign.LeftShiftEqual |
|
| AugAssign.MinusEqual |
|
| AugAssign.PartialVisitor<R> |
|
| AugAssign.PercentEqual |
|
| AugAssign.PlusEqual |
|
| AugAssign.RightShiftEqual |
|
| AugAssign.SlashEqual |
|
| AugAssign.StarStarEqual |
|
| AugAssign.TimesEqual |
|
| AugAssign.Visitor<R> |
|
| AugAssignment |
|
| AwaitPrimary |
|
| Axiom |
See https://www.w3.org/TR/owl2-syntax/#Axioms
|
| Axiom.AnnotationAxiom |
|
| Axiom.Assertion |
|
| Axiom.ClassAxiom |
|
| Axiom.DataPropertyAxiom |
|
| Axiom.DatatypeDefinition |
|
| Axiom.Declaration |
|
| Axiom.HasKey |
|
| Axiom.ObjectPropertyAxiom |
|
| Axiom.PartialVisitor<R> |
|
| Axiom.Visitor<R> |
|
| Base64Binary |
|
| BaseDecl |
|
| BasicForStatement |
|
| BasicForStatementNoShortIf |
|
| BeginExpression |
An explicit begin block (distinct from do for Scheme compatibility)
|
| Bicoder<T1,T2,V1,V2> |
A two-level encoder and decoder, operating both at a type level and an instance (data) level
|
| BigDecimalValue |
|
| BigfloatToBigint |
Primitive function which converts a bigfloat (arbitrary-precision decimal) to a bigint (arbitrary-precision integer).
|
| BigfloatToFloat32 |
Primitive function which converts a bigfloat (arbitrary-precision decimal) to a float32 (32-bit floating-point).
|
| BigfloatToFloat64 |
Primitive function which converts a bigfloat (arbitrary-precision decimal) to a float64 (64-bit floating-point).
|
| BigintToBigfloat |
Primitive function which converts a bigint (arbitrary-precision integer) to a bigfloat (arbitrary-precision decimal).
|
| BigintToInt16 |
Primitive function which converts a bigint (arbitrary-precision integer) to an int16 (16-bit signed integer).
|
| BigintToInt32 |
Primitive function which converts a bigint (arbitrary-precision integer) to an int32 (32-bit signed integer).
|
| BigintToInt64 |
Primitive function which converts a bigint (arbitrary-precision integer) to an int64 (64-bit signed integer).
|
| BigintToInt8 |
Primitive function which converts a bigint (arbitrary-precision integer) to an int8 (8-bit signed integer).
|
| BigintToUint16 |
Primitive function which converts a bigint (arbitrary-precision integer) to a uint16 (16-bit unsigned integer).
|
| BigintToUint32 |
Primitive function which converts a bigint (arbitrary-precision integer) to a uint32 (32-bit unsigned integer).
|
| BigintToUint64 |
Primitive function which converts a bigint (arbitrary-precision integer) to a uint64 (64-bit unsigned integer).
|
| BigintToUint8 |
Primitive function which converts a bigint (arbitrary-precision integer) to a uint8 (8-bit unsigned integer).
|
| Bimap |
Map over both sides of an Either value.
|
| Bimap |
Transforms both keys and values.
|
| Bimap |
Map over both elements of a pair.
|
| BinaryBooleanOperator |
|
| BinaryBooleanOperator.And |
|
| BinaryBooleanOperator.Or |
|
| BinaryBooleanOperator.PartialVisitor<R> |
|
| BinaryBooleanOperator.Visitor<R> |
|
| BinaryBooleanOperator.Xor |
|
| BinaryExpression |
|
| BinaryOperator |
|
| BinaryOperator.Boolean_ |
|
| BinaryOperator.Comparison |
|
| BinaryOperator.PartialVisitor<R> |
|
| BinaryOperator.Power |
|
| BinaryOperator.Visitor<R> |
|
| BinaryToBytes |
|
| BinaryToString |
Primitive function which converts binary data to a string.
|
| Bind |
Bind (flatMap) for Either: sequence an Either with a function that returns Either.
|
| Bind |
Monadic bind for flows.
|
| Bind |
Monadic bind for optional values (flatMap).
|
| Binding |
A field with an optional type scheme, used to bind variables to terms in a 'let' expression
|
| Binding |
|
| BitwiseAnd |
|
| BitwiseOr |
|
| BitwiseXor |
|
| BlankNode |
|
| BlankNode |
|
| BlankNodeLabel |
|
| BlankNodeLabel_Alts |
|
| BlankNodeLabel_Alts.PartialVisitor<R> |
|
| BlankNodeLabel_Alts.PnCharsU |
|
| BlankNodeLabel_Alts.Regex |
|
| BlankNodeLabel_Alts.Visitor<R> |
|
| BlankNodeLabel_ListOfAlts_Option_Elmt |
|
| BlankNodeLabel_ListOfAlts_Option_Elmt.PartialVisitor<R> |
|
| BlankNodeLabel_ListOfAlts_Option_Elmt.Period |
|
| BlankNodeLabel_ListOfAlts_Option_Elmt.PnChars |
|
| BlankNodeLabel_ListOfAlts_Option_Elmt.Visitor<R> |
|
| Block |
|
| Block |
|
| Block.Indented |
|
| Block.PartialVisitor<R> |
|
| Block.Simple |
|
| Block.Visitor<R> |
|
| BlockStatement |
|
| BlockStatement.Class_ |
|
| BlockStatement.LocalVariableDeclaration |
|
| BlockStatement.PartialVisitor<R> |
|
| BlockStatement.Statement |
|
| BlockStatement.Visitor<R> |
|
| BlockStyle |
Formatting option for code blocks
|
| Boolean_ |
|
| BooleanArgument |
|
| BooleanArgument.PartialVisitor<R> |
|
| BooleanArgument.Value |
|
| BooleanArgument.Variable |
|
| BooleanArgument.Visitor<R> |
|
| BooleanArray |
|
| BooleanArray.Array |
|
| BooleanArray.PartialVisitor<R> |
|
| BooleanArray.Simple |
|
| BooleanArray.Visitor<R> |
|
| BooleanLiteral |
|
| BooleanLiteral.False |
|
| BooleanLiteral.PartialVisitor<R> |
|
| BooleanLiteral.True |
|
| BooleanLiteral.Visitor<R> |
|
| BooleanStyle |
The style of boolean literals in a dialect
|
| BooleanStyle.HashTF |
|
| BooleanStyle.PartialVisitor<R> |
|
| BooleanStyle.TNil |
|
| BooleanStyle.TrueFalse |
|
| BooleanStyle.Visitor<R> |
|
| Bootstrap |
Bootstrapping entry point: loads Hydra modules from JSON and generates
code for a target language.
|
| Bootstrap |
A module which provides a minimal typing environment for decoding other modules from JSON.
|
| BracketedTripleExpr |
|
| BracketExpr |
An expression enclosed by brackets
|
| Brackets |
Matching open and close bracket symbols
|
| BreakStatement |
|
| ByArgs |
|
| ByArgs.Order |
|
| ByArgs.Other |
|
| ByArgs.PartialVisitor<R> |
|
| ByArgs.Token |
|
| ByArgs.Visitor<R> |
|
| ByOtherArgs |
|
| ByOtherArgs.Comparator |
|
| ByOtherArgs.Other |
|
| ByOtherArgs.PartialVisitor<R> |
|
| ByOtherArgs.Visitor<R> |
|
| Byte_ |
|
| CapturePattern |
|
| Cardinality |
|
| Cardinality.Ast |
|
| Cardinality.PartialVisitor<R> |
|
| Cardinality.Plus |
|
| Cardinality.Quest |
|
| Cardinality.RepeatRange |
|
| Cardinality.Visitor<R> |
|
| Case |
|
| CaseAlternative |
|
| CaseBlock |
|
| CaseClause |
A clause in a case expression
|
| CaseConvention |
A naming convention for symbols, such as camelCase or snake_case
|
| CaseConvention.Camel |
|
| CaseConvention.LowerSnake |
|
| CaseConvention.PartialVisitor<R> |
|
| CaseConvention.Pascal |
|
| CaseConvention.UpperSnake |
|
| CaseConvention.Visitor<R> |
|
| CaseConversionTestCase |
A test case which checks that strings are converted between different case conventions correctly
|
| CaseExpression |
|
| CaseExpression |
A case expression
|
| CaseExpression |
Case dispatch on a value.
|
| CaseRhs |
The right-hand side of a pattern-matching alternative
|
| Cases |
Pattern matches on Maybe.
|
| CaseStatement |
A union elimination; a case statement
|
| CaseTree |
|
| CaseTree.Case |
|
| CaseTree.PartialVisitor<R> |
|
| CaseTree.TypeCase |
|
| CaseTree.Visitor<R> |
|
| CastExpression |
|
| CastExpression_Lambda |
|
| CastExpression_NotPlusMinus |
|
| CastExpression_Primitive |
|
| CastExpression_RefAndBounds |
|
| CastExpression.Lambda |
|
| CastExpression.NotPlusMinus |
|
| CastExpression.PartialVisitor<R> |
|
| CastExpression.Primitive |
|
| CastExpression.Visitor<R> |
|
| Cat |
Filters and extracts Just values.
|
| Cat |
Concatenates a list of strings into a single string.
|
| Cat2 |
Concatenates two strings.
|
| CatchClause |
|
| Catches |
|
| CatchFormalParameter |
|
| CatchType |
|
| Ceiling |
Rounds up to the nearest integer.
|
| ChainedTraversal |
|
| ChainedTraversalElement |
|
| ChainedTraversalElement.Method |
|
| ChainedTraversalElement.PartialVisitor<R> |
|
| ChainedTraversalElement.Self |
|
| ChainedTraversalElement.Visitor<R> |
|
| CharacterLiteral |
A character literal.
|
| CharAt |
Retrieves the character at a given index in a string.
|
| Chars |
DSL interface providing character primitive operations.
|
| Checking |
Type checking and type reconstruction (type-of) for the results of Hydra unification and inference
|
| Checking |
Term decoders for hydra.error.checking
|
| Checking |
DSL functions for hydra.error.checking
|
| Checking |
Term encoders for hydra.error.checking
|
| CheckingError |
An error that occurred during type checking
|
| CheckingError.IncorrectUnification |
A post-unification consistency check failure
|
| CheckingError.NotAForallType |
A type that is not a forall type when one was expected
|
| CheckingError.NotAFunctionType |
A type that is not a function type when one was expected
|
| CheckingError.PartialVisitor<R> |
|
| CheckingError.TypeArityMismatch |
A type constructor applied to the wrong number of arguments
|
| CheckingError.TypeMismatch |
A type mismatch between expected and actual types
|
| CheckingError.UnboundTypeVariables |
Type variables that are not bound in scope
|
| CheckingError.UnequalTypes |
Multiple types that should be equal but are not
|
| CheckingError.UnsupportedTermVariant |
A term variant that the type checker does not support
|
| CheckingError.UntypedLambda |
A lambda expression without a type annotation on its parameter
|
| CheckingError.UntypedLetBinding |
A let binding without a type annotation
|
| CheckingError.Visitor<R> |
|
| ChooseArgs |
|
| ChooseArgs.Function |
|
| ChooseArgs.PartialVisitor<R> |
|
| ChooseArgs.PredicateTraversal |
|
| ChooseArgs.Traversal |
|
| ChooseArgs.Visitor<R> |
|
| Class_ |
See https://www.w3.org/TR/owl2-syntax/#Classes
|
| ClassAssertion |
A class assertion
|
| ClassAssertion |
|
| ClassAxiom |
|
| ClassAxiom.DisjointClasses |
|
| ClassAxiom.DisjointUnion |
|
| ClassAxiom.EquivalentClasses |
|
| ClassAxiom.PartialVisitor<R> |
|
| ClassAxiom.SubClassOf |
|
| ClassAxiom.Visitor<R> |
|
| ClassBody |
|
| ClassBodyDeclaration |
|
| ClassBodyDeclaration.ClassMember |
|
| ClassBodyDeclaration.ConstructorDeclaration |
|
| ClassBodyDeclaration.InstanceInitializer |
|
| ClassBodyDeclaration.PartialVisitor<R> |
|
| ClassBodyDeclaration.StaticInitializer |
|
| ClassBodyDeclaration.Visitor<R> |
|
| ClassBodyDeclarationWithComments |
|
| ClassDeclaration |
|
| ClassDeclaration.Enum_ |
|
| ClassDeclaration.Normal |
|
| ClassDeclaration.PartialVisitor<R> |
|
| ClassDeclaration.Visitor<R> |
|
| ClassDefinition |
|
| Classes |
Term decoders for hydra.classes
|
| Classes |
DSL functions for hydra.classes
|
| Classes |
Term encoders for hydra.classes
|
| ClassExpression |
|
| ClassExpression.Class_ |
|
| ClassExpression.DataAllValuesFrom |
|
| ClassExpression.DataExactCardinality |
|
| ClassExpression.DataHasValue |
|
| ClassExpression.DataMaxCardinality |
|
| ClassExpression.DataMinCardinality |
|
| ClassExpression.DataSomeValuesFrom |
|
| ClassExpression.ObjectAllValuesFrom |
|
| ClassExpression.ObjectExactCardinality |
|
| ClassExpression.ObjectHasSelf |
|
| ClassExpression.ObjectHasValue |
|
| ClassExpression.ObjectIntersectionOf |
|
| ClassExpression.ObjectMaxCardinality |
|
| ClassExpression.ObjectMinCardinality |
|
| ClassExpression.ObjectOneOf |
|
| ClassExpression.ObjectSomeValuesFrom |
|
| ClassExpression.ObjectUnionOf |
|
| ClassExpression.PartialVisitor<R> |
|
| ClassExpression.Visitor<R> |
|
| ClassInstanceCreationExpression |
|
| ClassInstanceCreationExpression_Qualifier |
|
| ClassInstanceCreationExpression_Qualifier.Expression |
|
| ClassInstanceCreationExpression_Qualifier.PartialVisitor<R> |
|
| ClassInstanceCreationExpression_Qualifier.Primary |
|
| ClassInstanceCreationExpression_Qualifier.Visitor<R> |
|
| ClassLiteral |
|
| ClassLiteral.Boolean_ |
|
| ClassLiteral.NumericType |
|
| ClassLiteral.PartialVisitor<R> |
|
| ClassLiteral.Type |
|
| ClassLiteral.Visitor<R> |
|
| ClassLiteral.Void_ |
|
| ClassMemberDeclaration |
|
| ClassMemberDeclaration.Class_ |
|
| ClassMemberDeclaration.Field |
|
| ClassMemberDeclaration.Interface |
|
| ClassMemberDeclaration.Method |
|
| ClassMemberDeclaration.None |
|
| ClassMemberDeclaration.PartialVisitor<R> |
|
| ClassMemberDeclaration.Visitor<R> |
|
| ClassModifier |
|
| ClassModifier.Abstract |
|
| ClassModifier.Annotation |
|
| ClassModifier.Final |
|
| ClassModifier.PartialVisitor<R> |
|
| ClassModifier.Private |
|
| ClassModifier.Protected |
|
| ClassModifier.Public |
|
| ClassModifier.Static |
|
| ClassModifier.Strictfp |
|
| ClassModifier.Visitor<R> |
|
| ClassOrInterfaceType |
|
| ClassOrInterfaceType.Class_ |
|
| ClassOrInterfaceType.Interface |
|
| ClassOrInterfaceType.PartialVisitor<R> |
|
| ClassOrInterfaceType.Visitor<R> |
|
| ClassOrInterfaceTypeToInstantiate |
|
| ClassPattern |
|
| ClassType |
|
| ClassTypeQualifier |
|
| ClassTypeQualifier.None |
|
| ClassTypeQualifier.Package_ |
|
| ClassTypeQualifier.Parent |
|
| ClassTypeQualifier.PartialVisitor<R> |
|
| ClassTypeQualifier.Visitor<R> |
|
| Closed |
See https://www.w3.org/TR/shacl/#ClosedPatterConstraintComponent
|
| ClosedPattern |
|
| ClosedPattern.Capture |
|
| ClosedPattern.Class_ |
|
| ClosedPattern.Group |
|
| ClosedPattern.Literal |
|
| ClosedPattern.Mapping |
|
| ClosedPattern.PartialVisitor<R> |
|
| ClosedPattern.Sequence |
|
| ClosedPattern.Value |
|
| ClosedPattern.Visitor<R> |
|
| ClosedPattern.Wildcard |
|
| Code |
|
| Code_Elmt |
|
| Code_Elmt.PartialVisitor<R> |
|
| Code_Elmt.Regex |
|
| Code_Elmt.Sequence |
|
| Code_Elmt.Uchar |
|
| Code_Elmt.Visitor<R> |
|
| CodeDecl |
|
| CodeDecl_Alts |
|
| CodeDecl_Alts.Code |
|
| CodeDecl_Alts.PartialVisitor<R> |
|
| CodeDecl_Alts.Percnt |
|
| CodeDecl_Alts.Visitor<R> |
|
| CodeGeneration |
Pure code generation pipeline for bootstrapping Hydra across languages.
|
| Coder |
Functions for encoding Hydra modules as Haskell modules
|
| Coder |
Java code generator: converts Hydra modules to Java source code
|
| Coder |
Lisp code generator: converts Hydra type and term modules to Lisp AST
|
| Coder |
Python code generator: converts Hydra modules to Python source code
|
| Coder |
Scala code generator: converts Hydra modules to Scala source code
|
| Coder |
SHACL coder: converts Hydra types and terms to SHACL shapes and RDF descriptions
|
| Coder |
Property graph element coders for mapping Hydra terms to property graph elements
|
| Coder |
Encoding functions for converting GraphSON syntax to JSON.
|
| Coder<V1,V2> |
An encoder and decoder; a bidirectional transformation between two types
|
| CoderDirection |
Indicates either the 'out' or the 'in' direction of a coder
|
| CoderDirection.Decode |
|
| CoderDirection.Encode |
|
| CoderDirection.PartialVisitor<R> |
|
| CoderDirection.Visitor<R> |
|
| Coders |
Convenience functions for working with Hydra coders.
|
| Coders |
Term decoders for hydra.coders
|
| Coders |
DSL functions for hydra.coders
|
| Coders |
Term encoders for hydra.coders
|
| CoderUtils |
Common utilities for language coders, providing shared patterns for term decomposition and analysis.
|
| ColumnName |
A name for a domain which serves to identify the role played by that domain in the given relation; a 'role name' in Codd
|
| ColumnSchema<T> |
An abstract specification of the domain represented by a column in a relation; a role
|
| ColumnType |
A column type, consisting of a name and a value type
|
| CommaStarEtc |
|
| Comment |
A comment
|
| CommentStyle |
The style of a comment
|
| CommentStyle.Block |
|
| CommentStyle.Datum |
|
| CommentStyle.Line |
|
| CommentStyle.PartialVisitor<R> |
|
| CommentStyle.Visitor<R> |
|
| CommonConstraint |
Any of a number of constraint parameters which can be applied either to node or property shapes
|
| CommonConstraint.And |
See https://www.w3.org/TR/shacl/#AndConstraintComponent
|
| CommonConstraint.Class_ |
See https://www.w3.org/TR/shacl/#ClassConstraintComponent
|
| CommonConstraint.Closed |
See https://www.w3.org/TR/shacl/#ClosedConstraintComponent
|
| CommonConstraint.Datatype |
See https://www.w3.org/TR/shacl/#DatatypeConstraintComponent
|
| CommonConstraint.Disjoint |
See https://www.w3.org/TR/shacl/#DisjointConstraintComponent
|
| CommonConstraint.Equals |
See https://www.w3.org/TR/shacl/#EqualsConstraintComponent
|
| CommonConstraint.HasValue |
Specifies the condition that at least one value node is equal to the given RDF term.
|
| CommonConstraint.In |
Specifies the condition that each value node is a member of a provided SHACL list.
|
| CommonConstraint.LanguageIn |
See https://www.w3.org/TR/shacl/#LanguageInConstraintComponent
|
| CommonConstraint.MaxExclusive |
See https://www.w3.org/TR/shacl/#MaxExclusiveConstraintComponent
|
| CommonConstraint.MaxInclusive |
See https://www.w3.org/TR/shacl/#MaxInclusiveConstraintComponent
|
| CommonConstraint.MaxLength |
See https://www.w3.org/TR/shacl/#MaxLengthConstraintComponent
|
| CommonConstraint.MinExclusive |
See https://www.w3.org/TR/shacl/#MinExclusiveConstraintComponent
|
| CommonConstraint.MinInclusive |
See https://www.w3.org/TR/shacl/#MinInclusiveConstraintComponent
|
| CommonConstraint.MinLength |
See https://www.w3.org/TR/shacl/#MinLengthConstraintComponent
|
| CommonConstraint.Node |
See https://www.w3.org/TR/shacl/#NodeConstraintComponent
|
| CommonConstraint.NodeKind |
See https://www.w3.org/TR/shacl/#NodeKindConstraintComponent
|
| CommonConstraint.Not |
See https://www.w3.org/TR/shacl/#NotConstraintComponent
|
| CommonConstraint.Or |
See https://www.w3.org/TR/shacl/#OrConstraintComponent
|
| CommonConstraint.PartialVisitor<R> |
|
| CommonConstraint.Pattern |
See https://www.w3.org/TR/shacl/#PatternConstraintComponent
|
| CommonConstraint.Property |
See https://www.w3.org/TR/shacl/#PropertyConstraintComponent
|
| CommonConstraint.Visitor<R> |
|
| CommonConstraint.Xone |
See https://www.w3.org/TR/shacl/#XoneConstraintComponent
|
| CommonProperties |
Common constraint parameters and other properties for SHACL shapes
|
| Compare |
Compares two values and returns a Comparison (LessThan, EqualTo, or GreaterThan).
|
| CompareOp |
|
| CompareOp.Eq |
|
| CompareOp.Gt |
|
| CompareOp.Gte |
|
| CompareOp.In |
|
| CompareOp.Is |
|
| CompareOp.Isnot |
|
| CompareOp.Lt |
|
| CompareOp.Lte |
|
| CompareOp.Noteq |
|
| CompareOp.Notin |
|
| CompareOp.PartialVisitor<R> |
|
| CompareOp.Visitor<R> |
|
| CompareOpBitwiseOrPair |
|
| Comparison |
|
| Comparison |
An equality judgement: less than, equal to, or greater than
|
| Comparison.EqualTo |
|
| Comparison.GreaterThan |
|
| Comparison.LessThan |
|
| Comparison.PartialVisitor<R> |
|
| Comparison.Visitor<R> |
|
| ComparisonConstraint |
One of several comparison operators
|
| ComparisonConstraint.Equal |
|
| ComparisonConstraint.GreaterThan |
|
| ComparisonConstraint.GreaterThanOrEqual |
|
| ComparisonConstraint.LessThan |
|
| ComparisonConstraint.LessThanOrEqual |
|
| ComparisonConstraint.NotEqual |
|
| ComparisonConstraint.PartialVisitor<R> |
|
| ComparisonConstraint.Visitor<R> |
|
| ComparisonExpression |
|
| ComparisonFeatures |
Comparison operators and functions
|
| ComparisonOperator |
|
| ComparisonOperator |
|
| ComparisonOperator.Eq |
|
| ComparisonOperator.Eq |
|
| ComparisonOperator.Gt |
|
| ComparisonOperator.Gt |
|
| ComparisonOperator.Gte |
|
| ComparisonOperator.Gte |
|
| ComparisonOperator.Lt |
|
| ComparisonOperator.Lt |
|
| ComparisonOperator.Lte |
|
| ComparisonOperator.Lte |
|
| ComparisonOperator.Neq |
|
| ComparisonOperator.Neq |
|
| ComparisonOperator.PartialVisitor<R> |
|
| ComparisonOperator.PartialVisitor<R> |
|
| ComparisonOperator.Visitor<R> |
|
| ComparisonOperator.Visitor<R> |
|
| CompilationUnit |
|
| CompilationUnit.Modular |
|
| CompilationUnit.Ordinary |
|
| CompilationUnit.PartialVisitor<R> |
|
| CompilationUnit.Visitor<R> |
|
| ComplexNumber |
|
| Compose |
Composes two Maybe-returning functions.
|
| CompositeTypedValue |
|
| CompoundStatement |
|
| CompoundStatement.ClassDef |
|
| CompoundStatement.For |
|
| CompoundStatement.Function |
|
| CompoundStatement.If |
|
| CompoundStatement.Match |
|
| CompoundStatement.PartialVisitor<R> |
|
| CompoundStatement.Try |
|
| CompoundStatement.Visitor<R> |
|
| CompoundStatement.While |
|
| CompoundStatement.With |
|
| Concat |
Concatenates a list of lists.
|
| Concat2 |
Concatenates two lists.
|
| ConcatArgs |
|
| ConcatArgs.PartialVisitor<R> |
|
| ConcatArgs.String_ |
|
| ConcatArgs.Traversal |
|
| ConcatArgs.Visitor<R> |
|
| CondClause |
A clause in a cond expression
|
| CondExpression |
Multi-branch conditional.
|
| Conditional |
|
| ConditionalAndExpression |
|
| ConditionalExpression |
|
| ConditionalExpression_TernaryCond |
|
| ConditionalExpression_TernaryLambda |
|
| ConditionalExpression.PartialVisitor<R> |
|
| ConditionalExpression.Simple |
|
| ConditionalExpression.TernaryCond |
|
| ConditionalExpression.TernaryLambda |
|
| ConditionalExpression.Visitor<R> |
|
| ConditionalOrExpression |
|
| Configuration |
|
| ConflictingModuleNamespaceError |
A module namespace which, when mapped to a target language's directory or package structure, conflicts with another module's mapped namespace.
|
| ConflictingVariantNameError |
A union type variant name which, when capitalized and concatenated with its type name, conflicts with another type definition name.
|
| Conjunction |
|
| ConnectedComponentConstants |
|
| ConnectedComponentConstants.Component |
|
| ConnectedComponentConstants.Edges |
|
| ConnectedComponentConstants.PartialVisitor<R> |
|
| ConnectedComponentConstants.PropertyName |
|
| ConnectedComponentConstants.Visitor<R> |
|
| Cons |
Prepends an element to a list.
|
| ConsExpression |
A cons expression: (cons head tail)
|
| ConsList<T> |
A persistent (immutable, shared-tail) singly-linked list.
|
| ConstantConditionError |
An application of ifElse where the condition is a literal boolean, creating a dead branch (optional)
|
| ConstantDeclaration |
|
| ConstantDefinition |
A constant definition.
|
| ConstantExpression |
|
| ConstantModifier |
|
| ConstantModifier.Annotation |
|
| ConstantModifier.Final |
|
| ConstantModifier.PartialVisitor<R> |
|
| ConstantModifier.Public |
|
| ConstantModifier.Static |
|
| ConstantModifier.Visitor<R> |
|
| Constants |
A module for tier-0 constants.
|
| ConstrainingFacet |
See https://www.w3.org/TR/xmlschema-2/#non-fundamental
|
| Construct |
Functions for constructing GraphSON vertices from property graph vertices.
|
| Constructor |
A data constructor
|
| Constructor.Ordinary |
An ordinary (positional) constructor
|
| Constructor.PartialVisitor<R> |
|
| Constructor.Record |
A record constructor
|
| Constructor.Visitor<R> |
|
| ConstructorBody |
|
| ConstructorDeclaration |
|
| ConstructorDeclarator |
|
| ConstructorModifier |
|
| ConstructorModifier.Annotation |
|
| ConstructorModifier.PartialVisitor<R> |
|
| ConstructorModifier.Private |
|
| ConstructorModifier.Protected |
|
| ConstructorModifier.Public |
|
| ConstructorModifier.Visitor<R> |
|
| ConstructorPattern |
A constructor pattern matching a tagged value
|
| ConstructorWithComments |
A data constructor together with any comments
|
| ConstructRecordExpression |
A record constructor expression
|
| Context |
An execution context for tracing and diagnostics, threaded through function calls
|
| Context |
Term decoders for hydra.context
|
| Context |
DSL functions for hydra.context
|
| Context |
Term encoders for hydra.context
|
| ContextType |
A type with a context (type class constraints)
|
| ContinueStatement |
|
| Core |
Term decoders for hydra.core
|
| Core |
Term decoders for hydra.error.core
|
| Core |
DSL functions for hydra.core
|
| Core |
DSL functions for hydra.error.core
|
| Core |
Term encoders for hydra.core
|
| Core |
Term encoders for hydra.error.core
|
| Core |
Extraction and validation for hydra.core types
|
| Core |
String representations of hydra.core types
|
| Core |
String representations of hydra.error.core types
|
| Core |
Validation functions for core terms and types
|
| Cos |
Computes the cosine of an angle.
|
| Cosh |
Computes the hyperbolic cosine.
|
| Create |
|
| Ctor |
|
| Ctor_Primary |
|
| Ctor_Secondary |
|
| Ctor.PartialVisitor<R> |
|
| Ctor.Primary |
|
| Ctor.Secondary |
|
| Ctor.Visitor<R> |
|
| CypherFeatures |
A set of features which characterize an OpenCypher query or implementation.
|
| Data |
|
| Data_Annotate |
|
| Data_Anonymous |
|
| Data_Apply |
|
| Data_ApplyInfix |
|
| Data_ApplyType |
|
| Data_ApplyUnary |
|
| Data_ApplyUsing |
|
| Data_Ascribe |
|
| Data_Assign |
|
| Data_Block |
|
| Data_ContextFunction |
|
| Data_Do |
|
| Data_EndMarker |
|
| Data_Eta |
|
| Data_For |
|
| Data_ForYield |
|
| Data_Function |
|
| Data_FunctionData |
|
| Data_FunctionData.ContextFunction |
|
| Data_FunctionData.Function |
|
| Data_FunctionData.PartialVisitor<R> |
|
| Data_FunctionData.Visitor<R> |
|
| Data_If |
|
| Data_Interpolate |
|
| Data_Match |
|
| Data_Name |
|
| Data_New |
|
| Data_NewAnonymous |
|
| Data_Param |
|
| Data_PartialFunction |
|
| Data_PolyFunction |
|
| Data_QuotedMacroExpr |
|
| Data_QuotedMacroType |
|
| Data_Ref |
|
| Data_Ref.Anonymous |
|
| Data_Ref.ApplyUnary |
|
| Data_Ref.Name |
|
| Data_Ref.PartialVisitor<R> |
|
| Data_Ref.Select |
|
| Data_Ref.Super |
|
| Data_Ref.This |
|
| Data_Ref.Visitor<R> |
|
| Data_Repeated |
|
| Data_Return |
|
| Data_Select |
|
| Data_SplicedMacroExpr |
|
| Data_Super |
|
| Data_This |
|
| Data_Throw |
|
| Data_Try |
|
| Data_TryWithHandler |
|
| Data_Tuple |
|
| Data_While |
|
| Data_Xml |
|
| Data.Annotate |
|
| Data.Apply |
|
| Data.ApplyType |
|
| Data.ApplyUsing |
|
| Data.Ascribe |
|
| Data.Assign |
|
| Data.Block |
|
| Data.Do |
|
| Data.EndMarker |
|
| Data.Eta |
|
| Data.For |
|
| Data.ForYield |
|
| Data.FunctionData |
|
| Data.If |
|
| Data.Interpolate |
|
| Data.Lit |
|
| Data.Match |
|
| Data.New |
|
| Data.NewAnonymous |
|
| Data.Param |
|
| Data.PartialFunction |
|
| Data.PartialVisitor<R> |
|
| Data.Placeholder |
|
| Data.PolyFunction |
|
| Data.QuotedMacroExpr |
|
| Data.QuotedMacroType |
|
| Data.Ref |
|
| Data.Repeated |
|
| Data.Return |
|
| Data.SplicedMacroExpr |
|
| Data.Throw |
|
| Data.Try |
|
| Data.TryWithHandler |
|
| Data.Tuple |
|
| Data.Visitor<R> |
|
| Data.While |
|
| Data.Xml |
|
| DataAllValuesFrom |
|
| DatabaseFunctionFeatures |
Database functions
|
| DataComplementOf |
See https://www.w3.org/TR/owl2-syntax/#Complement_of_Data_Ranges
|
| DataDeclaration |
A data type declaration
|
| DataExactCardinality |
|
| DataHasValue |
|
| DataIntersectionOf |
See https://www.w3.org/TR/owl2-syntax/#Intersection_of_Data_Ranges
|
| DataMaxCardinality |
|
| DataMinCardinality |
|
| DataOneOf |
See https://www.w3.org/TR/owl2-syntax/#Enumeration_of_Literals
|
| DataOrNewtype |
The 'data' versus 'newtype keyword
|
| DataOrNewtype.Data |
|
| DataOrNewtype.Newtype |
|
| DataOrNewtype.PartialVisitor<R> |
|
| DataOrNewtype.Visitor<R> |
|
| DataProperty |
|
| DataPropertyAssertion |
|
| DataPropertyAxiom |
|
| DataPropertyAxiom.DataPropertyAxiom_ |
|
| DataPropertyAxiom.DataPropertyRange |
|
| DataPropertyAxiom.DisjointDataProperties |
|
| DataPropertyAxiom.EquivalentDataProperties |
|
| DataPropertyAxiom.FunctionalDataProperty |
|
| DataPropertyAxiom.PartialVisitor<R> |
|
| DataPropertyAxiom.SubDataPropertyOf |
|
| DataPropertyAxiom.Visitor<R> |
|
| DataPropertyDomain |
|
| DataPropertyExpression |
|
| DataPropertyRange |
|
| DataRange |
See https://www.w3.org/TR/owl2-syntax/#Data_Ranges
|
| DataRange.DataComplementOf |
|
| DataRange.DataIntersectionOf |
|
| DataRange.DataOneOf |
|
| DataRange.Datatype |
|
| DataRange.DatatypeRestriction |
|
| DataRange.DataUnionOf |
|
| DataRange.PartialVisitor<R> |
|
| DataRange.Visitor<R> |
|
| DataRow<V> |
A data row, containing optional-valued cells; one per column
|
| Dataset |
|
| DataSomeValuesFrom |
|
| Datatype |
|
| Datatype |
See https://www.w3.org/TR/owl2-syntax/#Datatypes
|
| Datatype |
|
| Datatype.AnySimpleType |
|
| Datatype.AnyType |
|
| Datatype.AnyURI |
|
| Datatype.Base64Binary |
|
| Datatype.Boolean_ |
|
| Datatype.Byte_ |
|
| Datatype.Date |
|
| Datatype.DateTime |
|
| Datatype.Decimal |
|
| Datatype.Double_ |
|
| Datatype.Duration |
|
| Datatype.ENTITIES |
|
| Datatype.ENTITY |
|
| Datatype.Float_ |
|
| Datatype.GDay |
|
| Datatype.GMonth |
|
| Datatype.GMonthDay |
|
| Datatype.GYear |
|
| Datatype.GYearMonth |
|
| Datatype.HexBinary |
|
| Datatype.ID |
|
| Datatype.IDREF |
|
| Datatype.IDREFS |
|
| Datatype.Int |
|
| Datatype.Integer_ |
|
| Datatype.Language |
|
| Datatype.Long_ |
|
| Datatype.Name |
|
| Datatype.NegativeInteger |
|
| Datatype.NMTOKEN |
|
| Datatype.NonNegativeInteger |
|
| Datatype.NonPositiveInteger |
|
| Datatype.NormalizedString |
|
| Datatype.NOTATION |
|
| Datatype.Other |
|
| Datatype.PartialVisitor<R> |
|
| Datatype.PartialVisitor<R> |
|
| Datatype.PositiveInteger |
|
| Datatype.QName |
|
| Datatype.Short_ |
|
| Datatype.String_ |
|
| Datatype.Time |
|
| Datatype.Token |
|
| Datatype.UnsignedByte |
|
| Datatype.UnsignedInt |
|
| Datatype.UnsignedLong |
|
| Datatype.UnsignedShort |
|
| Datatype.Visitor<R> |
|
| Datatype.Visitor<R> |
|
| Datatype.XmlSchema |
Note: XML Schema datatypes are treated as a special case in this model (not in the OWL 2 specification itself) because they are particularly common
|
| DatatypeDefinition |
|
| DataTypeFeatures |
Base interface for features that relate to supporting different data types.
|
| DatatypeRestriction |
See https://www.w3.org/TR/owl2-syntax/#Datatype_Restrictions
|
| DatatypeRestriction_ConstrainingFacet |
|
| DatatypeRestriction_ConstrainingFacet.Other |
|
| DatatypeRestriction_ConstrainingFacet.PartialVisitor<R> |
|
| DatatypeRestriction_ConstrainingFacet.Visitor<R> |
|
| DatatypeRestriction_ConstrainingFacet.XmlSchema |
Note: XML Schema constraining facets are treated as a special case in this model (not in the OWL 2 specification itself) because they are particularly common
|
| DatatypeRestriction_Constraint |
|
| DataUnionOf |
See https://www.w3.org/TR/owl2-syntax/#Union_of_Data_Ranges
|
| Date |
|
| DateAddArgs |
|
| DateArgument |
|
| DateArgument.PartialVisitor<R> |
|
| DateArgument.Value |
|
| DateArgument.Variable |
|
| DateArgument.Visitor<R> |
|
| DateDiffArgs |
|
| DateDiffArgs.Date |
|
| DateDiffArgs.PartialVisitor<R> |
|
| DateDiffArgs.Traversal |
|
| DateDiffArgs.Visitor<R> |
|
| DateLiteral |
|
| DateTime |
|
| DateTime |
|
| DeannotateTermTestCase |
A test case which strips all annotations from a term and compares the result with the expected term
|
| DeannotateTypeTestCase |
A test case which strips all annotations from a type and compares the result with the expected type
|
| Decimal |
|
| Decimal |
|
| Decl |
|
| Decl_Def |
|
| Decl_Given |
|
| Decl_Type |
|
| Decl_Val |
|
| Decl_Var |
|
| Decl.Def |
|
| Decl.Given |
|
| Decl.PartialVisitor<R> |
|
| Decl.Type |
|
| Decl.Val |
|
| Decl.Var |
|
| Decl.Visitor<R> |
|
| Declaration |
A data or value declaration
|
| Declaration |
|
| Declaration.Data |
A data type declaration
|
| Declaration.PartialVisitor<R> |
|
| Declaration.Type |
A type synonym declaration
|
| Declaration.TypedBinding |
A typed binding
|
| Declaration.ValueBinding |
A value binding
|
| Declaration.Visitor<R> |
|
| DeclarationHead |
The left-hand side of a declaration
|
| DeclarationHead.Application |
An application-style declaration head
|
| DeclarationHead.Parens |
A parenthesized declaration head
|
| DeclarationHead.PartialVisitor<R> |
|
| DeclarationHead.Simple |
A simple name
|
| DeclarationHead.Visitor<R> |
|
| DeclarationWithComments |
A data declaration together with any comments
|
| Decode |
JSON decoding for Hydra terms.
|
| Decode |
YAML-to-JSON decoding.
|
| Decoding |
Functions for generating term decoders from type modules
|
| Decoding |
Decoding functions for JSON data
|
| DecodingError |
An error that occurred during decoding of a term
|
| Decorators |
|
| DedupArgs |
|
| DedupArgs.PartialVisitor<R> |
|
| DedupArgs.ScopeString |
|
| DedupArgs.String_ |
|
| DedupArgs.Visitor<R> |
|
| Default |
|
| DefaultValue |
|
| Definition<A> |
An instance of a type like sh:Shape or sh:NodeShape, together with a unique IRI for that instance
|
| Definition |
A definition, which may be either a term or type definition
|
| Definition.PartialVisitor<R> |
|
| Definition.Term |
A term definition
|
| Definition.Type |
A type definition
|
| Definition.Visitor<R> |
|
| DefinitionNotInModuleNamespaceError |
A definition whose name does not have the module's namespace as a prefix.
|
| Defn |
|
| Defn_Class |
|
| Defn_Def |
|
| Defn_Enum |
|
| Defn_EnumCase |
|
| Defn_ExtensionGroup |
|
| Defn_Given |
|
| Defn_GivenAlias |
|
| Defn_Macro |
|
| Defn_Object |
|
| Defn_RepeatedEnumCase |
|
| Defn_Trait |
|
| Defn_Type |
|
| Defn_Val |
|
| Defn_Var |
|
| Defn.Class_ |
|
| Defn.Def |
|
| Defn.Enum_ |
|
| Defn.EnumCase |
|
| Defn.ExtensionGroup |
|
| Defn.Given |
|
| Defn.GivenAlias |
|
| Defn.Macro |
|
| Defn.Object_ |
|
| Defn.PartialVisitor<R> |
|
| Defn.RepeatedEnumCase |
|
| Defn.Trait |
|
| Defn.Type |
|
| Defn.Val |
|
| Defn.Var |
|
| Defn.Visitor<R> |
|
| DelegatedEvaluationTestCase |
A test case in which we delegate evaluation of an input term and an expected output term to a target programming language like Haskell, Java, or Python, checking whether the term evaluates as expected when translated into that language
|
| Delete |
|
| Delete |
Removes a key from the map.
|
| Delete |
Removes an element from a set.
|
| DeleteFeatures |
Delete operations
|
| DelStatement |
|
| DelTarget |
|
| DelTarget.DelTAtom |
|
| DelTarget.PartialVisitor<R> |
|
| DelTarget.PrimaryAndName |
|
| DelTarget.PrimaryAndSlices |
|
| DelTarget.Visitor<R> |
|
| DelTargets |
|
| DelTAtom |
|
| DelTAtom.Name |
|
| DelTAtom.PartialVisitor<R> |
|
| DelTAtom.Target |
|
| DelTAtom.Targets |
|
| DelTAtom.Visitor<R> |
|
| Deriving |
A 'deriving' statement
|
| Description |
A graph of RDF statements together with a distinguished subject and/or object node
|
| DestructuringBinding |
A destructuring binding in a let expression
|
| DestructuringPattern |
A destructuring pattern
|
| DestructuringPattern.Associative |
Associative/map destructuring: {:keys [a b]} in Clojure
|
| DestructuringPattern.PartialVisitor<R> |
|
| DestructuringPattern.Rest |
Destructuring with a rest element: [a b & rest] (leading symbols + rest symbol)
|
| DestructuringPattern.Sequential |
Sequential destructuring: [a b c] in Clojure, (a b c) in others
|
| DestructuringPattern.Visitor<R> |
|
| Dialect |
A Lisp dialect
|
| Dialect.Clojure |
|
| Dialect.CommonLisp |
|
| Dialect.EmacsLisp |
|
| Dialect.PartialVisitor<R> |
|
| Dialect.Scheme |
|
| Dialect.Visitor<R> |
|
| Dict |
|
| Dictcomp |
|
| Difference |
Computes the set difference.
|
| DifferentIndividuals |
|
| DimExpr |
|
| Dims |
|
| Direction |
The direction of an edge or edge pattern
|
| Direction.Both |
|
| Direction.In |
|
| Direction.Out |
|
| Direction.PartialVisitor<R> |
|
| Direction.Undirected |
|
| Direction.Visitor<R> |
|
| DirectionAndVarargs |
|
| Directive |
|
| Directive.BaseDecl |
|
| Directive.PartialVisitor<R> |
|
| Directive.PrefixDecl |
|
| Directive.Visitor<R> |
|
| DisjointClasses |
|
| DisjointDataProperties |
|
| DisjointObjectProperties |
|
| DisjointUnion |
See https://www.w3.org/TR/owl2-syntax/#Disjoint_Union_of_Class_Expressions
|
| Disjunction |
|
| Div |
Performs division on two numbers.
|
| Docstring |
A documentation string
|
| DoExpression |
Sequential evaluation of expressions, returning the last.
|
| DoStatement |
|
| DottedAsName |
|
| DottedName |
|
| DottedPair |
A dotted pair literal: '(a .
|
| Double_ |
|
| Double_ |
|
| DoubleStarPattern |
|
| DoubleStarredKvpair |
|
| DoubleStarredKvpair.Pair |
|
| DoubleStarredKvpair.PartialVisitor<R> |
|
| DoubleStarredKvpair.Starred |
|
| DoubleStarredKvpair.Visitor<R> |
|
| DoubleStarTypeParameter |
|
| DoubleValue |
|
| DoubleValue.Finite |
|
| DoubleValue.Infinity |
|
| DoubleValue.NegativeInfinity |
|
| DoubleValue.NotANumber |
|
| DoubleValue.PartialVisitor<R> |
|
| DoubleValue.Visitor<R> |
|
| Drop |
Drops the first n elements.
|
| DropWhile |
Drops elements while predicate is true.
|
| DuplicateBindingError |
A duplicate binding name in a let expression
|
| DuplicateDefinitionNameError |
Two or more definitions in the same module share the same name
|
| DuplicateFieldError |
A duplicate field name in a record or union type
|
| DuplicateModuleNamespaceError |
Two or more modules in the same package share the same namespace
|
| DuplicateRecordTypeFieldNamesError |
A record type with duplicate field names
|
| DuplicateUnionTypeFieldNamesError |
A union type with duplicate field names
|
| Duration |
|
| Duration |
|
| E |
Returns the mathematical constant e.
|
| Echar |
|
| Edge<V> |
An edge
|
| Edge |
An abstract edge based on a record type
|
| EdgeBuilder<V> |
A builder object for property graph edges.
|
| EdgeFeatures |
Features that are related to Edge operations.
|
| EdgeLabel |
|
| EdgeLabel |
The label of an edge
|
| EdgeProjectionPattern |
|
| EdgePropertyFeatures |
Features that are related to Edge Property objects.
|
| EdgeSpec |
A mapping specification producing edges of a specified label.
|
| EdgeType<T> |
The type of an edge
|
| EdgeTypeBuilder<T> |
A builder object for property graph edge types.
|
| Either |
Eliminate an Either value by applying one of two functions.
|
| Either<L,R> |
A simple class for disjoint unions (Either types) in Java.
|
| Either.Left<L,R> |
A Left value in an Either.
|
| Either.PartialVisitor<L,R,T> |
Partial visitor interface with a default case for non-exhaustive matching.
|
| Either.Right<L,R> |
A Right value in an Either.
|
| Either.Visitor<L,R,T> |
Visitor interface for pattern matching on Either values.
|
| Eithers |
DSL interface providing either primitive operations.
|
| Eithers |
Evaluation-level implementations of Either functions for the Hydra interpreter.
|
| EitherType |
A type which provides a choice between a 'left' type and a 'right' type
|
| Elem |
Checks if an element is in a list.
|
| Element<V> |
Either a vertex or an edge
|
| Element.Edge<V> |
|
| Element.PartialVisitor<V,R> |
|
| Element.Vertex<V> |
|
| Element.Visitor<V,R> |
|
| ElementBuilder<V,S,B extends ElementBuilder<V,S,B>> |
Abstract base class for building property graph elements (vertices or edges) with properties.
|
| ElementFeatures |
Features that are related to Element objects.
|
| ElementKind |
The kind of an element: vertex or edge
|
| ElementKind.Edge |
|
| ElementKind.PartialVisitor<R> |
|
| ElementKind.Vertex |
|
| ElementKind.Visitor<R> |
|
| ElementSpec |
Either a vertex specification or an edge specification
|
| ElementSpec.Edge |
|
| ElementSpec.PartialVisitor<R> |
|
| ElementSpec.Vertex |
|
| ElementSpec.Visitor<R> |
|
| ElementTree<V> |
An element together with its dependencies in some context
|
| ElementType<T> |
The type of a vertex or edge
|
| ElementType.Edge<T> |
|
| ElementType.PartialVisitor<T,R> |
|
| ElementType.Vertex<T> |
|
| ElementType.Visitor<T,R> |
|
| ElementTypeBuilder<T,S,B extends ElementTypeBuilder<T,S,B>> |
Abstract base class for building property graph element types (vertex types or edge types) with property types.
|
| ElementTypeTree<T> |
An element type together with its dependencies in some context
|
| ElementValue |
|
| ElementValue.Annotation |
|
| ElementValue.ConditionalExpression |
|
| ElementValue.ElementValueArrayInitializer |
|
| ElementValue.PartialVisitor<R> |
|
| ElementValue.Visitor<R> |
|
| ElementValueArrayInitializer |
|
| ElementValuePair |
|
| Elems |
Returns all values.
|
| Elimination |
A corresponding elimination for an introduction term
|
| Elimination.PartialVisitor<R> |
|
| Elimination.Record |
Eliminates a record by projecting a given field
|
| Elimination.Union |
Eliminates a union term by matching over the fields of the union.
|
| Elimination.Visitor<R> |
|
| Elimination.Wrap |
Unwrap a wrapped term
|
| EliminationVariant |
The identifier of an elimination constructor
|
| EliminationVariant.PartialVisitor<R> |
|
| EliminationVariant.Record |
|
| EliminationVariant.Union |
|
| EliminationVariant.Visitor<R> |
|
| EliminationVariant.Wrap |
|
| Empty |
Creates an empty map.
|
| Empty |
Creates an empty set.
|
| EmptyCaseStatementError |
A case statement with no cases and no default (optional)
|
| EmptyLetBindingsError |
A let expression with an empty list of bindings (optional)
|
| EmptyRecordTypeError |
A record type with no fields; TypeUnit is preferred for the unit-like case (optional)
|
| EmptyTermAnnotationError |
A term annotation with an empty annotation map (optional)
|
| EmptyTypeAnnotationError |
A type annotation with an empty annotation map (optional)
|
| EmptyTypeNameInTermError |
A record, injection, projection, or case statement with an empty type name (optional)
|
| EmptyUnionTypeError |
A union type with no alternatives; TypeVoid is preferred (optional)
|
| Encode |
JSON encoding for Hydra terms.
|
| Encode |
JSON-to-YAML encoding.
|
| Encoding |
Functions for generating term encoders from type modules
|
| EnhancedForCond |
|
| EnhancedForStatement |
|
| EnhancedForStatementNoShortIf |
|
| ENTITIES |
|
| Entity |
|
| ENTITY |
|
| Entity.AnnotationProperty |
|
| Entity.Class_ |
|
| Entity.DataProperty |
|
| Entity.Datatype |
|
| Entity.NamedIndividual |
|
| Entity.ObjectProperty |
|
| Entity.PartialVisitor<R> |
|
| Entity.Visitor<R> |
|
| EnumBody |
|
| EnumBody_Element |
|
| EnumConstant |
|
| EnumConstantModifier |
|
| EnumConstantName |
|
| EnumDeclaration |
|
| Enumerator |
|
| Enumerator_CaseGenerator |
|
| Enumerator_Generator |
|
| Enumerator_Guard |
|
| Enumerator_Val |
|
| Enumerator.CaseGenerator |
|
| Enumerator.Generator |
|
| Enumerator.Guard |
|
| Enumerator.PartialVisitor<R> |
|
| Enumerator.Val |
|
| Enumerator.Visitor<R> |
|
| Equal |
Tests equality.
|
| Equality |
DSL interface providing equality and comparison primitive operations.
|
| Equality |
Evaluation-level implementations of Equality functions for the Hydra interpreter.
|
| EqualityExpression |
|
| EqualityExpression_Binary |
|
| EqualityExpression.Equal |
|
| EqualityExpression.NotEqual |
|
| EqualityExpression.PartialVisitor<R> |
|
| EqualityExpression.Unary |
|
| EqualityExpression.Visitor<R> |
|
| EqualityFunction<T> |
|
| EqualityFunction.Relation |
|
| EquivalentClasses |
|
| EquivalentDataProperties |
|
| EquivalentObjectProperties |
|
| Error_ |
An error of any kind, with kernel errors particularly differentiated
|
| Error_.Checking |
A type checking error
|
| Error_.Decoding |
An error that occurred during decoding of a term
|
| Error_.DuplicateBinding |
A duplicate binding name error
|
| Error_.DuplicateField |
A duplicate field name error
|
| Error_.Other |
Any other error
|
| Error_.PartialVisitor<R> |
|
| Error_.UndefinedField |
A reference to an undefined field
|
| Error_.UndefinedTermVariable |
A reference to an undefined term variable
|
| Error_.UnexpectedTermVariant |
An unexpected term variant
|
| Error_.UnexpectedTypeVariant |
An unexpected type variant
|
| Error_.Unification |
A type unification error
|
| Error_.UntypedTermVariable |
A term variable whose type is not known
|
| Error_.Visitor<R> |
|
| Errors |
Term decoders for hydra.errors
|
| Errors |
DSL functions for hydra.errors
|
| Errors |
Term encoders for hydra.errors
|
| Errors |
String representations of hydra.error types
|
| EtaExpansionTestCase |
A test case which performs eta expansion (adding missing lambda abstractions) on a given term and compares the result with the expected result
|
| Eval |
|
| EvaluationStyle |
One of two evaluation styles: eager or lazy
|
| EvaluationStyle.Eager |
|
| EvaluationStyle.Lazy |
|
| EvaluationStyle.PartialVisitor<R> |
|
| EvaluationStyle.Visitor<R> |
|
| EvaluationTestCase |
A test case which evaluates (reduces) a given term and compares it with the expected result
|
| Even |
Determines whether an integer is even.
|
| ExceptBlock |
|
| ExceptExpression |
|
| ExceptionType |
|
| ExceptionType.Class_ |
|
| ExceptionType.PartialVisitor<R> |
|
| ExceptionType.Variable |
|
| ExceptionType.Visitor<R> |
|
| ExceptStarBlock |
|
| Exclusion |
|
| ExclusiveOrExpression |
|
| ExistentialSubquery |
|
| ExistentialSubquery.PartialVisitor<R> |
|
| ExistentialSubquery.Pattern |
|
| ExistentialSubquery.Regular |
|
| ExistentialSubquery.Visitor<R> |
|
| Exp |
Computes e raised to a power.
|
| ExplicitConstructorInvocation |
|
| ExplicitConstructorInvocation_Variant |
|
| ExplicitConstructorInvocation_Variant.PartialVisitor<R> |
|
| ExplicitConstructorInvocation_Variant.Primary |
|
| ExplicitConstructorInvocation_Variant.Super |
|
| ExplicitConstructorInvocation_Variant.This |
|
| ExplicitConstructorInvocation_Variant.Visitor<R> |
|
| ExplicitProcedureInvocation |
|
| Export |
An export statement
|
| Export |
|
| Export.Declaration |
An exported declaration
|
| Export.Module |
An exported module
|
| Export.PartialVisitor<R> |
|
| Export.Visitor<R> |
|
| ExportDeclaration |
An export/provide declaration.
|
| Expr |
An abstract expression
|
| Expr.Brackets |
A bracketed expression
|
| Expr.Const |
A constant symbol
|
| Expr.Indent |
An indented expression
|
| Expr.Op |
An operator expression
|
| Expr.PartialVisitor<R> |
|
| Expr.Seq |
A sequence of expressions joined by a separator, treated as structural layout (not subject to parenthesization)
|
| Expr.Visitor<R> |
|
| Expression |
|
| Expression |
A data expression
|
| Expression |
|
| Expression |
A Lisp expression
|
| Expression |
|
| Expression |
|
| Expression.And |
Logical and (short-circuiting)
|
| Expression.Application |
A function application
|
| Expression.Application |
Function application: (f arg1 arg2 ...)
|
| Expression.Assignment |
|
| Expression.Associative |
|
| Expression.Begin |
Sequential evaluation (explicit begin block)
|
| Expression.Binary |
|
| Expression.Case |
A case expression
|
| Expression.Case |
Case/match dispatch
|
| Expression.Cond |
Multi-branch conditional
|
| Expression.Conditional |
|
| Expression.Cons |
A cons expression
|
| Expression.ConstructRecord |
A record constructor expression
|
| Expression.Do |
A 'do' expression
|
| Expression.Do |
Sequential evaluation (progn/do/begin)
|
| Expression.DottedPair |
A dotted pair literal
|
| Expression.FieldAccess |
Field access on a record/struct
|
| Expression.If |
An 'if' expression
|
| Expression.If |
Conditional expression
|
| Expression.InfixApplication |
An infix application
|
| Expression.Lambda |
A lambda expression
|
| Expression.Lambda |
|
| Expression.Lambda |
Anonymous function
|
| Expression.Lambda |
|
| Expression.LeftSection |
A left section expression
|
| Expression.Let |
A 'let' expression
|
| Expression.Let |
Local variable binding
|
| Expression.List |
A list expression
|
| Expression.List |
A list literal
|
| Expression.Literal |
A literal value
|
| Expression.Literal |
A literal value
|
| Expression.Map |
A map/association literal
|
| Expression.Not |
Logical negation
|
| Expression.Or |
Logical or (short-circuiting)
|
| Expression.Parens |
A parenthesized expression
|
| Expression.PartialVisitor<R> |
|
| Expression.PartialVisitor<R> |
|
| Expression.PartialVisitor<R> |
|
| Expression.PartialVisitor<R> |
|
| Expression.PartialVisitor<R> |
|
| Expression.PrefixApplication |
A prefix application
|
| Expression.Property |
|
| Expression.Quasiquote |
A quasiquoted expression
|
| Expression.Quote |
A quoted expression
|
| Expression.RightSection |
A right section expression
|
| Expression.Set |
A set literal
|
| Expression.SExpression |
An arbitrary S-expression (escape hatch for dialect-specific forms)
|
| Expression.Simple |
|
| Expression.SplicingUnquote |
A splicing unquote within a quasiquote
|
| Expression.Tuple |
A tuple expression
|
| Expression.TypeAnnotation |
A type-annotated expression
|
| Expression.TypeSignature |
A type signature expression
|
| Expression.Unary |
|
| Expression.Unquote |
An unquoted expression within a quasiquote
|
| Expression.UpdateRecord |
A record update expression
|
| Expression.Variable |
A variable reference
|
| Expression.Variable |
Variable reference
|
| Expression.Variable |
|
| Expression.Vector |
A vector literal
|
| Expression.Vertex |
|
| Expression.Visitor<R> |
|
| Expression.Visitor<R> |
|
| Expression.Visitor<R> |
|
| Expression.Visitor<R> |
|
| Expression.Visitor<R> |
|
| ExpressionName |
|
| ExpressionStatement |
|
| ExtraFeatures<A> |
Additional features which are needed for the complete specification of language constraints in Hydra, above and beyond TinkerPop Graph.Features
|
| ExtraPropertySet |
|
| Factor |
|
| Factor.Complement |
|
| Factor.Negative |
|
| Factor.PartialVisitor<R> |
|
| Factor.Positive |
|
| Factor.Simple |
|
| Factor.Visitor<R> |
|
| Features |
An interface that represents the capabilities of a Graph implementation.
|
| Field |
A name/term pair
|
| Field |
A field (name/type pair)
|
| FieldAccess |
|
| FieldAccess |
Field access on a record/struct.
|
| FieldAccess_Qualifier |
|
| FieldAccess_Qualifier.PartialVisitor<R> |
|
| FieldAccess_Qualifier.Primary |
|
| FieldAccess_Qualifier.Super |
|
| FieldAccess_Qualifier.Typed |
|
| FieldAccess_Qualifier.Visitor<R> |
|
| FieldDeclaration |
|
| FieldDefinition |
A field in a record type definition
|
| FieldModifier |
|
| FieldModifier.Annotation |
|
| FieldModifier.Final |
|
| FieldModifier.PartialVisitor<R> |
|
| FieldModifier.Private |
|
| FieldModifier.Protected |
|
| FieldModifier.Public |
|
| FieldModifier.Static |
|
| FieldModifier.Transient |
|
| FieldModifier.Visitor<R> |
|
| FieldModifier.Volatile |
|
| FieldType |
A name/type pair
|
| FieldUpdate |
A field name and value
|
| FieldWithComments |
A field together with any comments
|
| File |
|
| FileExtension |
A file extension (without the dot), e.g.
|
| Filter |
Filters a list, keeping only elements that satisfy the predicate.
|
| Filter |
Filters map entries by value.
|
| FilterExpression |
|
| FilterWithKey |
Filters map entries by key and value.
|
| Finally |
|
| Find |
Finds the first element in a list that satisfies the predicate.
|
| Find |
Finds the first substring matching a regex pattern.
|
| FindAll |
Finds all non-overlapping substrings matching a regex pattern.
|
| FindWithDefault |
Looks up with a default value.
|
| First |
Extracts the first element of a pair.
|
| FlattenLetTermsTestCase |
A test case which flattens nested let terms, lifting inner bindings to the outer let, and compares the result with the expected term
|
| Float_ |
|
| Float32ToBigfloat |
Primitive function which converts a float32 (32-bit floating-point) to a bigfloat (arbitrary-precision decimal).
|
| Float64ToBigfloat |
Primitive function which converts a float64 (64-bit floating-point) to a bigfloat (arbitrary-precision decimal).
|
| FloatArgument |
|
| FloatArgument.PartialVisitor<R> |
|
| FloatArgument.Value |
|
| FloatArgument.Variable |
|
| FloatArgument.Visitor<R> |
|
| FloatingPointLiteral |
Note: this is an approximation which ignores encoding
|
| FloatingPointType |
|
| FloatingPointType.Double_ |
|
| FloatingPointType.Float_ |
|
| FloatingPointType.PartialVisitor<R> |
|
| FloatingPointType.Visitor<R> |
|
| FloatLiteral |
A floating-point literal
|
| FloatLiteral |
|
| FloatType |
A floating-point type
|
| FloatType.Bigfloat |
An arbitrary-precision floating-point type
|
| FloatType.Float32 |
A 32-bit floating-point type
|
| FloatType.Float64 |
A 64-bit floating-point type
|
| FloatType.PartialVisitor<R> |
|
| FloatType.Visitor<R> |
|
| FloatValue |
A floating-point literal value
|
| FloatValue |
|
| FloatValue.Bigfloat |
An arbitrary-precision floating-point value
|
| FloatValue.Finite |
|
| FloatValue.Float32 |
A 32-bit floating-point value
|
| FloatValue.Float64 |
A 64-bit floating-point value
|
| FloatValue.Infinity |
|
| FloatValue.NegativeInfinity |
|
| FloatValue.NotANumber |
|
| FloatValue.PartialVisitor<R> |
|
| FloatValue.PartialVisitor<R> |
|
| FloatValue.Visitor<R> |
|
| FloatValue.Visitor<R> |
|
| Floor |
Rounds down to the nearest integer.
|
| Foldl |
Monadic left fold over a list using Either.
|
| Foldl |
Left-associative fold of a list with a binary function and initial value.
|
| FoldOperation |
A predefined fold operation for testing foldOverTerm
|
| FoldOperation.CollectLabels |
Collect labels (first element of pairs where first is a string literal)
|
| FoldOperation.CollectListLengths |
Collect the lengths of all list terms (returns list of integers in traversal order)
|
| FoldOperation.PartialVisitor<R> |
|
| FoldOperation.SumInt32Literals |
Sum all Int32 literals in a term
|
| FoldOperation.Visitor<R> |
|
| FoldOverTermTestCase |
A test case which applies a fold operation over a term and compares the result
|
| Foldr |
Right-associative fold of a list with a binary function and initial value.
|
| ForallType |
A universally quantified type; the System F equivalent of a type scheme, and the type-level equivalent of a lambda term.
|
| ForCond |
|
| ForeignKey |
A mapping from certain columns of a source relation to primary key columns of a target relation
|
| ForIfClause |
|
| ForIfClauses |
|
| ForInit |
|
| ForInit.LocalVariable |
|
| ForInit.PartialVisitor<R> |
|
| ForInit.Statements |
|
| ForInit.Visitor<R> |
|
| FormalParameter |
|
| FormalParameter_Simple |
|
| FormalParameter.PartialVisitor<R> |
|
| FormalParameter.Simple |
|
| FormalParameter.VariableArity |
|
| FormalParameter.Visitor<R> |
|
| Formatting |
String formatting types and functions.
|
| ForStatement |
|
| ForStatement |
|
| ForStatement.Basic |
|
| ForStatement.Enhanced |
|
| ForStatement.PartialVisitor<R> |
|
| ForStatement.Visitor<R> |
|
| ForStatementNoShortIf |
|
| ForStatementNoShortIf.Basic |
|
| ForStatementNoShortIf.Enhanced |
|
| ForStatementNoShortIf.PartialVisitor<R> |
|
| ForStatementNoShortIf.Visitor<R> |
|
| ForUpdate |
|
| FreeVariablesTestCase |
A test case which computes the free variables of a term and compares the result with an expected set of names
|
| FromArgs |
|
| FromArgs.PartialVisitor<R> |
|
| FromArgs.String_ |
|
| FromArgs.Traversal |
|
| FromArgs.Vertex |
|
| FromArgs.Visitor<R> |
|
| FromJust |
Extracts the value from Just.
|
| FromLeft |
Extract the Left value from an Either, or return a default value.
|
| FromList |
Creates a map from a list of pairs.
|
| FromList |
Creates a set from a list of elements.
|
| FromList |
Converts a list of character code points to a string.
|
| FromMaybe |
Extracts the value from an optional, or returns a default if Nothing.
|
| FromRight |
Extract the Right value from an Either, or return a default value.
|
| Function |
A function
|
| Function.Elimination |
An elimination for any of a few term variants
|
| Function.Lambda |
A function abstraction (lambda)
|
| Function.PartialVisitor<R> |
|
| Function.Primitive |
A reference to a built-in (primitive) function
|
| Function.Visitor<R> |
|
| Function3<A,B,C,R> |
A functional interface representing a function that accepts three arguments and produces a result.
|
| Function4<A,B,C,D,R> |
A functional interface representing a function that accepts four arguments and produces a result.
|
| FunctionalDataProperty |
|
| FunctionalObjectProperty |
|
| FunctionDefinition |
A named function definition.
|
| FunctionDefinition |
|
| FunctionDefRaw |
|
| FunctionFeatures |
Standard Cypher functions
|
| FunctionInvocation |
|
| FunctionStructure<Env> |
A structured representation of a function term's components, replacing ad-hoc tuples.
|
| FunctionType |
A function type, also known as an arrow type
|
| FunctionType |
A function type
|
| FunctionVariant |
The identifier of a function constructor
|
| FunctionVariant.Elimination |
|
| FunctionVariant.Lambda |
|
| FunctionVariant.PartialVisitor<R> |
|
| FunctionVariant.Primitive |
|
| FunctionVariant.Visitor<R> |
|
| FuncType |
|
| FuncTypeComment |
|
| GDay |
|
| GenAIFunctionFeatures |
GenAI functions
|
| Generation |
I/O wrapper for Hydra code generation in Java.
|
| GenericLiteral |
|
| GenericLiteral.Boolean_ |
|
| GenericLiteral.Date |
|
| GenericLiteral.GenericLiteralCollection |
|
| GenericLiteral.GenericLiteralMap |
|
| GenericLiteral.GenericLiteralRange |
|
| GenericLiteral.GenericLiteralSet |
|
| GenericLiteral.Inf |
|
| GenericLiteral.Nan |
|
| GenericLiteral.NestedTraversal |
|
| GenericLiteral.Null |
|
| GenericLiteral.Numeric |
|
| GenericLiteral.PartialVisitor<R> |
|
| GenericLiteral.String_ |
|
| GenericLiteral.StructureVertex |
|
| GenericLiteral.TerminatedTraversal |
|
| GenericLiteral.TraversalCardinality |
|
| GenericLiteral.TraversalDirection |
|
| GenericLiteral.TraversalDT |
|
| GenericLiteral.TraversalMerge |
|
| GenericLiteral.TraversalPick |
|
| GenericLiteral.TraversalToken |
|
| GenericLiteral.Visitor<R> |
|
| GenericLiteralArgument |
|
| GenericLiteralArgument.PartialVisitor<R> |
|
| GenericLiteralArgument.Value |
|
| GenericLiteralArgument.Variable |
|
| GenericLiteralArgument.Visitor<R> |
|
| GenericLiteralArgumentAndNestedTraversal |
|
| GenericLiteralArgumentAndOptionalTraversalBiFunctionArgument |
|
| GenericLiteralArgumentAndTraversalBiFunctionArgument |
|
| GenericLiteralArgumentAndTraversalPredicate |
|
| GenericLiteralArgumentAndTraversalPredicate.Literal |
|
| GenericLiteralArgumentAndTraversalPredicate.PartialVisitor<R> |
|
| GenericLiteralArgumentAndTraversalPredicate.Predicate |
|
| GenericLiteralArgumentAndTraversalPredicate.Visitor<R> |
|
| GenericLiteralCollection |
|
| GenericLiteralList |
|
| GenericLiteralListArgument |
|
| GenericLiteralListArgument.PartialVisitor<R> |
|
| GenericLiteralListArgument.Value |
|
| GenericLiteralListArgument.Variable |
|
| GenericLiteralListArgument.Visitor<R> |
|
| GenericLiteralMap |
|
| GenericLiteralMapArgument |
|
| GenericLiteralMapArgument.PartialVisitor<R> |
|
| GenericLiteralMapArgument.Value |
|
| GenericLiteralMapArgument.Variable |
|
| GenericLiteralMapArgument.Visitor<R> |
|
| GenericLiteralMapNullableArgument |
|
| GenericLiteralMapNullableArgument.PartialVisitor<R> |
|
| GenericLiteralMapNullableArgument.Value |
|
| GenericLiteralMapNullableArgument.Variable |
|
| GenericLiteralMapNullableArgument.Visitor<R> |
|
| GenericLiteralMapNullableArgumentAndTraversalCardinalityArgument |
|
| GenericLiteralMapNullableArgumentOrNestedTraversal |
|
| GenericLiteralMapNullableArgumentOrNestedTraversal.Map |
|
| GenericLiteralMapNullableArgumentOrNestedTraversal.PartialVisitor<R> |
|
| GenericLiteralMapNullableArgumentOrNestedTraversal.Traversal |
|
| GenericLiteralMapNullableArgumentOrNestedTraversal.Visitor<R> |
|
| GenericLiteralRange |
|
| GenericLiteralRange.Integer_ |
|
| GenericLiteralRange.PartialVisitor<R> |
|
| GenericLiteralRange.String_ |
|
| GenericLiteralRange.Visitor<R> |
|
| GenericLiteralSet |
|
| Genexp |
|
| GenexpHead |
|
| GenexpHead.Assignment |
|
| GenexpHead.Expression |
|
| GenexpHead.PartialVisitor<R> |
|
| GenexpHead.Visitor<R> |
|
| GMonth |
|
| GMonthDay |
|
| Graph |
DSL functions for hydra.graph
|
| Graph |
|
| Graph |
A graph, or lexical environment which binds names to terms, types, primitives, and metadata
|
| Graph<V> |
A graph; a self-contained collection of vertices and edges
|
| Graph |
String representations of hydra.graph types
|
| GraphFeatures |
Features specific to a operations of a graph.
|
| GraphFunctionFeatures |
Graph functions
|
| GraphPattern |
A query pattern which matches within a designated component subgraph
|
| Graphs |
DSL for constructing property graph types (vertex and edge types, property types)
and values (vertices, edges, and properties).
|
| GraphSchema<T> |
A graph schema; a vertex and edge types for the vertices and edges of a graph conforming to the schema
|
| Group |
|
| Group |
Groups consecutive equal elements.
|
| Group.Expression |
|
| Group.PartialVisitor<R> |
|
| Group.Visitor<R> |
|
| Group.Yield |
|
| GroupPattern |
|
| GroupTripleExpr |
|
| GroupTripleExpr.MultiElementGroup |
|
| GroupTripleExpr.PartialVisitor<R> |
|
| GroupTripleExpr.SingleElementGroup |
|
| GroupTripleExpr.Visitor<R> |
|
| Gt |
Tests if the first value is greater than the second.
|
| Gte |
Tests if the first value is greater than or equal to the second.
|
| Guard |
|
| GYear |
|
| GYearMonth |
|
| HasArgs |
|
| HasArgs.PartialVisitor<R> |
|
| HasArgs.String_ |
|
| HasArgs.TraversalToken |
|
| HasArgs.Visitor<R> |
|
| HasKey |
See https://www.w3.org/TR/owl2-syntax/#Keys
|
| HasStringArgumentAndOptionalStringLiteralVarargs |
|
| HasStringArgumentAndOptionalStringLiteralVarargsRest |
|
| HasStringArgumentAndOptionalStringLiteralVarargsRest.Object_ |
|
| HasStringArgumentAndOptionalStringLiteralVarargsRest.PartialVisitor<R> |
|
| HasStringArgumentAndOptionalStringLiteralVarargsRest.Predicate |
|
| HasStringArgumentAndOptionalStringLiteralVarargsRest.StringObject |
|
| HasStringArgumentAndOptionalStringLiteralVarargsRest.StringPredicate |
|
| HasStringArgumentAndOptionalStringLiteralVarargsRest.Traversal |
|
| HasStringArgumentAndOptionalStringLiteralVarargsRest.Visitor<R> |
|
| HasTraversalTokenArgs |
|
| HasTraversalTokenArgsRest |
|
| HasTraversalTokenArgsRest.Literal |
|
| HasTraversalTokenArgsRest.PartialVisitor<R> |
|
| HasTraversalTokenArgsRest.Predicate |
|
| HasTraversalTokenArgsRest.Traversal |
|
| HasTraversalTokenArgsRest.Visitor<R> |
|
| Head |
Returns the first element of a list.
|
| HeaderRow |
A header row, containing column names (but no types or data)
|
| Helpers |
Helper functions for decoding terms to domain types
|
| Hex |
|
| HexBinary |
|
| HoistCaseStatementsTestCase |
A test case for the hoistCaseStatements function, which hoists case statements into let bindings, but only when they appear inside a lambda body.
|
| Hoisting |
Functions for deep term rewriting operations involving hoisting subterms or bindings into enclosing let terms.
|
| HoistLetBindingsTestCase |
A test case for hoistLetBindings with hoistAll=True, which hoists ALL nested let bindings to the top level of a let term, not just polymorphic ones.
|
| HoistPolymorphicLetBindingsTestCase |
A test case for the hoistPolymorphicLetBindings function, which hoists polymorphic let bindings to the top level of a let term.
|
| HoistPredicate |
A predefined predicate for testing hoistSubterms.
|
| HoistPredicate.Applications |
Hoist function applications that appear in non-top-level positions
|
| HoistPredicate.CaseStatements |
Hoist case statements (elimination unions) that appear in non-top-level positions
|
| HoistPredicate.Lists |
Hoist list terms that appear in non-top-level positions
|
| HoistPredicate.Nothing |
Never hoist anything (identity transformation for let terms)
|
| HoistPredicate.PartialVisitor<R> |
|
| HoistPredicate.Visitor<R> |
|
| HoistSubtermsTestCase |
A test case which hoists subterms into let bindings based on a predicate, and compares the result with the expected term.
|
| HydraTestBase |
Base class for Hydra test utilities providing common assertion methods.
|
| ID |
|
| Identifier |
|
| Identifier |
|
| Identity |
Returns its argument unchanged.
|
| IdInColl |
|
| IDREF |
|
| IDREFS |
|
| IfElse |
Performs conditional branching based on a boolean condition.
|
| IfExpression |
An 'if' expression
|
| IfExpression |
Conditional: (if test then else)
|
| IfStatement |
|
| IfTail |
|
| IfTail.Elif |
|
| IfTail.Else |
|
| IfTail.PartialVisitor<R> |
|
| IfTail.Visitor<R> |
|
| IfThenElseStatement |
|
| IfThenElseStatementNoShortIf |
|
| IfThenStatement |
|
| ImaginaryNumber |
|
| ImplicitProcedureInvocation |
|
| Import |
An import statement
|
| Import |
|
| ImportDeclaration |
|
| ImportDeclaration |
An import/require declaration.
|
| ImportDeclaration.PartialVisitor<R> |
|
| ImportDeclaration.SingleStaticImport |
|
| ImportDeclaration.SingleType |
|
| ImportDeclaration.StaticImportOnDemand |
|
| ImportDeclaration.TypeImportOnDemand |
|
| ImportDeclaration.Visitor<R> |
|
| Importee |
|
| Importee_Given |
|
| Importee_Name |
|
| Importee_Rename |
|
| Importee_Unimport |
|
| Importee.Given |
|
| Importee.GivenAll |
|
| Importee.Name |
|
| Importee.PartialVisitor<R> |
|
| Importee.Rename |
|
| Importee.Unimport |
|
| Importee.Visitor<R> |
|
| Importee.Wildcard |
|
| Importer |
|
| ImportExportSpec |
An import or export specification
|
| ImportExportStat |
|
| ImportExportStat.Export |
|
| ImportExportStat.Import |
|
| ImportExportStat.PartialVisitor<R> |
|
| ImportExportStat.Visitor<R> |
|
| ImportFrom |
|
| ImportFromAsName |
|
| ImportFromTargets |
|
| ImportFromTargets.Parens |
|
| ImportFromTargets.PartialVisitor<R> |
|
| ImportFromTargets.Simple |
|
| ImportFromTargets.Star |
|
| ImportFromTargets.Visitor<R> |
|
| ImportModifier |
An import modifier ('pattern' or 'type')
|
| ImportModifier.PartialVisitor<R> |
|
| ImportModifier.Pattern |
|
| ImportModifier.Type |
|
| ImportModifier.Visitor<R> |
|
| ImportName |
|
| ImportSpec |
An import specification describing how to import symbols
|
| ImportSpec.Alias |
Import with an alias: (:require [name :as alias]) in Clojure
|
| ImportSpec.All |
Import everything
|
| ImportSpec.Only |
Import specific symbols: (:require [name :refer [sym1 sym2]]) in Clojure
|
| ImportSpec.PartialVisitor<R> |
|
| ImportSpec.Rename |
Import with renaming: list of (from, to) symbol pairs
|
| ImportSpec.Visitor<R> |
|
| ImportStatement |
|
| ImportStatement.From |
|
| ImportStatement.Name |
|
| ImportStatement.PartialVisitor<R> |
|
| ImportStatement.Visitor<R> |
|
| Include |
|
| IncludeSet |
|
| InclusiveOrExpression |
|
| InContext<E> |
A particular domain object (such as an error) together with an execution context
|
| IncorrectUnificationError |
A post-unification consistency check failure
|
| IndentedExpression |
An expression indented in a certain style
|
| IndentStyle |
Any of several indentation styles
|
| IndentStyle.AllLines |
Indent all lines with the given string
|
| IndentStyle.PartialVisitor<R> |
|
| IndentStyle.SubsequentLines |
Indent only lines after the first with the given string
|
| IndentStyle.Visitor<R> |
|
| Individual |
|
| Individual.Anonymous |
|
| Individual.Named |
|
| Individual.PartialVisitor<R> |
|
| Individual.Visitor<R> |
|
| Inference |
Type inference following Algorithm W, extended for nominal terms and types
|
| InferenceFailureTestCase |
A test case providing a term for which type inference is expected to fail
|
| InferenceResult |
The result of applying inference rules to a term.
|
| InferenceTestCase |
A test case which performs type inference on a given term and compares the result with an expected type scheme
|
| InfixApplicationExpression |
An infix application expression
|
| InfixType |
An infix type application
|
| Init |
|
| Init |
Returns all elements except the last.
|
| Injection |
An instance of a union type; i.e.
|
| InlineShapeAnd |
|
| InlineShapeAtom |
|
| InlineShapeAtom_Sequence |
|
| InlineShapeAtom_Sequence2 |
|
| InlineShapeAtom.PartialVisitor<R> |
|
| InlineShapeAtom.Period |
|
| InlineShapeAtom.Sequence |
|
| InlineShapeAtom.Sequence2 |
|
| InlineShapeAtom.Sequence3 |
|
| InlineShapeAtom.Visitor<R> |
|
| InlineShapeDefinition |
|
| InlineShapeDefinition_ListOfAlts_Elmt |
|
| InlineShapeDefinition_ListOfAlts_Elmt.CLOSED |
|
| InlineShapeDefinition_ListOfAlts_Elmt.ExtraPropertySet |
|
| InlineShapeDefinition_ListOfAlts_Elmt.IncludeSet |
|
| InlineShapeDefinition_ListOfAlts_Elmt.PartialVisitor<R> |
|
| InlineShapeDefinition_ListOfAlts_Elmt.Visitor<R> |
|
| InlineShapeExpression |
|
| InlineShapeNot |
|
| InlineShapeOr |
|
| InlineShapeOrRef |
|
| InlineShapeOrRef.AtpNameLn |
|
| InlineShapeOrRef.AtpNameNs |
|
| InlineShapeOrRef.InlineShapeDefinition |
|
| InlineShapeOrRef.PartialVisitor<R> |
|
| InlineShapeOrRef.Sequence |
|
| InlineShapeOrRef.Visitor<R> |
|
| InnerTripleExpr |
|
| InnerTripleExpr.MultiElementGroup |
|
| InnerTripleExpr.MultiElementOneOf |
|
| InnerTripleExpr.PartialVisitor<R> |
|
| InnerTripleExpr.Visitor<R> |
|
| InQueryCall |
|
| Insert |
Adds an element to a set.
|
| Insert |
Adds an element to a set.
|
| InstanceInitializer |
|
| Int |
|
| Int16ToBigint |
Primitive function which converts an int16 (16-bit signed integer) to a bigint (arbitrary-precision integer).
|
| Int32ToBigint |
Primitive function which converts an int32 (32-bit signed integer) to a bigint (arbitrary-precision integer).
|
| Int64ToBigint |
Primitive function which converts an int64 (64-bit signed integer) to a bigint (arbitrary-precision integer).
|
| Int8ToBigint |
Primitive function which converts an int8 (8-bit signed integer) to a bigint (arbitrary-precision integer).
|
| Integer_ |
|
| Integer_ |
|
| IntegerArgument |
|
| IntegerArgument.PartialVisitor<R> |
|
| IntegerArgument.Value |
|
| IntegerArgument.Variable |
|
| IntegerArgument.Visitor<R> |
|
| IntegerLiteral |
Note: this is an approximation which ignores encoding
|
| IntegerLiteral |
An integer literal
|
| IntegerLiteral |
|
| IntegerRange |
|
| IntegerType |
An integer type
|
| IntegerType.Bigint |
An arbitrary-precision integer type
|
| IntegerType.Int16 |
A 16-bit signed integer type
|
| IntegerType.Int32 |
A 32-bit signed integer type
|
| IntegerType.Int64 |
A 64-bit signed integer type
|
| IntegerType.Int8 |
An 8-bit signed integer type
|
| IntegerType.PartialVisitor<R> |
|
| IntegerType.Uint16 |
A 16-bit unsigned integer type
|
| IntegerType.Uint32 |
A 32-bit unsigned integer type
|
| IntegerType.Uint64 |
A 64-bit unsigned integer type
|
| IntegerType.Uint8 |
An 8-bit unsigned integer type
|
| IntegerType.Visitor<R> |
|
| IntegerValue |
An integer literal value
|
| IntegerValue.Bigint |
An arbitrary-precision integer value
|
| IntegerValue.Int16 |
A 16-bit signed integer value (short value)
|
| IntegerValue.Int32 |
A 32-bit signed integer value (int value)
|
| IntegerValue.Int64 |
A 64-bit signed integer value (long value)
|
| IntegerValue.Int8 |
An 8-bit signed integer value
|
| IntegerValue.PartialVisitor<R> |
|
| IntegerValue.Uint16 |
A 16-bit unsigned integer value
|
| IntegerValue.Uint32 |
A 32-bit unsigned integer value (unsigned int)
|
| IntegerValue.Uint64 |
A 64-bit unsigned integer value (unsigned long)
|
| IntegerValue.Uint8 |
An 8-bit unsigned integer value (byte)
|
| IntegerValue.Visitor<R> |
|
| IntegralType |
|
| IntegralType.Byte_ |
|
| IntegralType.Char |
|
| IntegralType.Int |
|
| IntegralType.Long_ |
|
| IntegralType.PartialVisitor<R> |
|
| IntegralType.Short_ |
|
| IntegralType.Visitor<R> |
|
| Interactive |
|
| Intercalate |
Joins lists with a separator.
|
| Intercalate |
Joins a list of strings with a delimiter string.
|
| InterfaceBody |
|
| InterfaceDeclaration |
|
| InterfaceDeclaration.AnnotationType |
|
| InterfaceDeclaration.NormalInterface |
|
| InterfaceDeclaration.PartialVisitor<R> |
|
| InterfaceDeclaration.Visitor<R> |
|
| InterfaceMemberDeclaration |
|
| InterfaceMemberDeclaration.Class_ |
|
| InterfaceMemberDeclaration.Constant |
|
| InterfaceMemberDeclaration.Interface |
|
| InterfaceMemberDeclaration.InterfaceMethod |
|
| InterfaceMemberDeclaration.PartialVisitor<R> |
|
| InterfaceMemberDeclaration.Visitor<R> |
|
| InterfaceMethodDeclaration |
|
| InterfaceMethodModifier |
|
| InterfaceMethodModifier.Abstract |
|
| InterfaceMethodModifier.Annotation |
|
| InterfaceMethodModifier.Default |
|
| InterfaceMethodModifier.PartialVisitor<R> |
|
| InterfaceMethodModifier.Private |
|
| InterfaceMethodModifier.Public |
|
| InterfaceMethodModifier.Static |
|
| InterfaceMethodModifier.Strictfp |
|
| InterfaceMethodModifier.Visitor<R> |
|
| InterfaceModifier |
|
| InterfaceModifier.Abstract |
|
| InterfaceModifier.Annotation |
|
| InterfaceModifier.PartialVisitor<R> |
|
| InterfaceModifier.Private |
|
| InterfaceModifier.Protected |
|
| InterfaceModifier.Public |
|
| InterfaceModifier.Static |
|
| InterfaceModifier.Strictfb |
|
| InterfaceModifier.Visitor<R> |
|
| InterfaceType |
|
| Intersection |
Computes the intersection of two sets.
|
| Intersperse |
Inserts an element between list elements.
|
| InvalidForallParameterNameError |
A forall type parameter name that violates type variable naming conventions (optional)
|
| InvalidLambdaParameterNameError |
A lambda parameter name that violates naming conventions (optional)
|
| InvalidLetBindingNameError |
A let binding name that violates naming conventions (optional)
|
| InvalidModuleError |
An error indicating that a module is invalid
|
| InvalidModuleError.ConflictingVariantName |
A union variant name that conflicts with another type definition when mapped to a target language
|
| InvalidModuleError.DefinitionNotInModuleNamespace |
A definition whose name does not have the module's namespace as a prefix
|
| InvalidModuleError.DuplicateDefinitionName |
Two or more definitions in the same module share the same name
|
| InvalidModuleError.PartialVisitor<R> |
|
| InvalidModuleError.Visitor<R> |
|
| InvalidPackageError |
An error indicating that a package is invalid
|
| InvalidPackageError.ConflictingModuleNamespace |
Two module namespaces that conflict when mapped to a target language
|
| InvalidPackageError.DuplicateModuleNamespace |
Two or more modules in the same package share the same namespace
|
| InvalidPackageError.InvalidModule |
A module within the package is invalid
|
| InvalidPackageError.PartialVisitor<R> |
|
| InvalidPackageError.Visitor<R> |
|
| InvalidTermError |
An error indicating that a term is invalid
|
| InvalidTermError.ConstantCondition |
An ifElse with a literal boolean condition (optional)
|
| InvalidTermError.DuplicateBinding |
A duplicate binding name in a let expression
|
| InvalidTermError.DuplicateField |
A duplicate field name in a record or case statement
|
| InvalidTermError.EmptyCaseStatement |
A case statement with no cases and no default (optional)
|
| InvalidTermError.EmptyLetBindings |
A let expression with no bindings (optional)
|
| InvalidTermError.EmptyTermAnnotation |
A term annotation with an empty annotation map (optional)
|
| InvalidTermError.EmptyTypeNameInTerm |
A term with an empty type name (optional)
|
| InvalidTermError.InvalidLambdaParameterName |
A lambda parameter name violating naming conventions (optional)
|
| InvalidTermError.InvalidLetBindingName |
A let binding name violating naming conventions (optional)
|
| InvalidTermError.InvalidTypeLambdaParameterName |
A type lambda parameter name violating naming conventions (optional)
|
| InvalidTermError.NestedTermAnnotation |
Nested term annotations that should be merged (optional)
|
| InvalidTermError.PartialVisitor<R> |
|
| InvalidTermError.RedundantWrapUnwrap |
A no-op unwrap-of-wrap round-trip (optional)
|
| InvalidTermError.SelfApplication |
A variable applied to itself (optional)
|
| InvalidTermError.TermVariableShadowing |
A binding that shadows a variable already in scope (optional)
|
| InvalidTermError.TypeVariableShadowingInTypeLambda |
A type lambda parameter that shadows a type variable in scope (optional)
|
| InvalidTermError.UndefinedTermVariable |
A variable reference to an unbound term name
|
| InvalidTermError.UndefinedTypeVariableInBindingType |
An unbound type variable in a let binding's type scheme
|
| InvalidTermError.UndefinedTypeVariableInLambdaDomain |
An unbound type variable in a lambda domain annotation
|
| InvalidTermError.UndefinedTypeVariableInTypeApplication |
An unbound type variable in a type application term
|
| InvalidTermError.UnknownPrimitiveName |
A reference to an unknown primitive function
|
| InvalidTermError.UnnecessaryIdentityApplication |
An identity lambda applied to an argument (optional)
|
| InvalidTermError.UntypedTermVariable |
A term variable whose type is not known
|
| InvalidTermError.Visitor<R> |
|
| InvalidTypeError |
An error indicating that a type is invalid
|
| InvalidTypeError.DuplicateRecordTypeFieldNames |
A record type with duplicate field names
|
| InvalidTypeError.DuplicateUnionTypeFieldNames |
A union type with duplicate field names
|
| InvalidTypeError.EmptyRecordType |
A record type with no fields (optional)
|
| InvalidTypeError.EmptyTypeAnnotation |
A type annotation with an empty annotation map (optional)
|
| InvalidTypeError.EmptyUnionType |
A union type with no alternatives (optional)
|
| InvalidTypeError.InvalidForallParameterName |
A forall parameter name violating naming conventions (optional)
|
| InvalidTypeError.InvalidTypeSchemeVariableName |
A type scheme variable name violating naming conventions (optional)
|
| InvalidTypeError.NestedTypeAnnotation |
Nested type annotations that should be merged (optional)
|
| InvalidTypeError.NonComparableMapKeyType |
A map with a non-comparable key type
|
| InvalidTypeError.NonComparableSetElementType |
A set with a non-comparable element type
|
| InvalidTypeError.PartialVisitor<R> |
|
| InvalidTypeError.SingleVariantUnion |
A union type with only one variant (optional)
|
| InvalidTypeError.TypeVariableShadowingInForall |
A forall parameter that shadows a type variable in scope (optional)
|
| InvalidTypeError.UndefinedTypeVariable |
A type variable reference to an unbound name
|
| InvalidTypeError.Visitor<R> |
|
| InvalidTypeError.VoidInNonBottomPosition |
TypeVoid in a position where no value can be constructed (optional)
|
| InvalidTypeLambdaParameterNameError |
A type lambda parameter name that violates naming conventions (optional)
|
| InvalidTypeSchemeVariableNameError |
A type scheme variable name that violates type variable naming conventions (optional)
|
| InverseFunctionalObjectProperty |
|
| InverseObjectProperties |
|
| InverseObjectProperty |
|
| Inversion |
|
| Inversion.Not |
|
| Inversion.PartialVisitor<R> |
|
| Inversion.Simple |
|
| Inversion.Visitor<R> |
|
| IoOptionsKeys |
|
| IoOptionsKeys.PartialVisitor<R> |
|
| IoOptionsKeys.Reader |
|
| IoOptionsKeys.Visitor<R> |
|
| IoOptionsKeys.Writer |
|
| IoOptionsValues |
|
| IoOptionsValues.Graphml |
|
| IoOptionsValues.Graphson |
|
| IoOptionsValues.Gryo |
|
| IoOptionsValues.PartialVisitor<R> |
|
| IoOptionsValues.Visitor<R> |
|
| Iri |
|
| Iri |
An Internationalized Resource Identifier
|
| Iri.IriRef |
|
| Iri.PartialVisitor<R> |
|
| Iri.PrefixedName |
|
| Iri.Visitor<R> |
|
| IriOrLiteral |
An IRI or a literal; this type is a convenience for downstream models like SHACL which may exclude blank nodes
|
| IriOrLiteral.Iri |
|
| IriOrLiteral.Literal |
|
| IriOrLiteral.PartialVisitor<R> |
|
| IriOrLiteral.Visitor<R> |
|
| IriRange |
|
| IriRange_Sequence |
|
| IriRange.PartialVisitor<R> |
|
| IriRange.Sequence |
|
| IriRange.Sequence2 |
|
| IriRange.Visitor<R> |
|
| IriRef |
|
| IriRef_Elmt |
|
| IriRef_Elmt.PartialVisitor<R> |
|
| IriRef_Elmt.Regex |
|
| IriRef_Elmt.Uchar |
|
| IriRef_Elmt.Visitor<R> |
|
| IrreflexiveObjectProperty |
|
| IsAlphaNum |
Determines whether a character is alphanumeric (a letter or digit).
|
| IsEmpty |
Checks if a map is empty.
|
| IsEmpty |
Checks if a set is empty.
|
| IsEmpty |
Determines whether a string is empty.
|
| IsJust |
Checks if value is Just.
|
| IsLeft |
Check if an Either value is a Left.
|
| IsLower |
Determines whether a character is lowercase.
|
| IsNothing |
Checks if value is Nothing.
|
| IsRight |
Check if an Either value is a Right.
|
| IsSpace |
Determines whether a character is whitespace.
|
| IsUpper |
Determines whether a character is uppercase.
|
| ItemsPattern |
|
| JavaEnvironment |
Environment for Java code generation
|
| JavaFeatures |
Feature flags for the target Java version
|
| JavaSymbolClass |
Classification of a Java symbol for code generation
|
| JavaSymbolClass.Constant |
A constant value
|
| JavaSymbolClass.HoistedLambda |
A hoisted lambda wrapped in type lambdas.
|
| JavaSymbolClass.LocalVariable |
A local variable
|
| JavaSymbolClass.NullaryFunction |
A nullary function (no arguments)
|
| JavaSymbolClass.PartialVisitor<R> |
|
| JavaSymbolClass.UnaryFunction |
A unary function (single argument)
|
| JavaSymbolClass.Visitor<R> |
|
| JoinTypesTestCase |
A test case which joins two types (producing type constraints or failing).
|
| Json |
Utilities for extracting values from JSON objects
|
| JsonDecodeTestCase |
A test case for the Either-based JSON decoder.
|
| JsonEncodeTestCase |
A test case for the Either-based JSON encoder.
|
| JsonRoundtripTestCase |
A test case for round-trip encoding/decoding using the Either-based JSON functions.
|
| Keys |
Returns all keys.
|
| KeyValuePair |
|
| KeyValuePattern |
|
| Keyword |
A keyword (self-evaluating symbol).
|
| Keyword |
|
| Keyword.Edges |
|
| Keyword.Keys |
|
| Keyword.New |
|
| Keyword.PartialVisitor<R> |
|
| Keyword.Values |
|
| Keyword.Visitor<R> |
|
| KeywordOrIdentifier |
|
| KeywordOrIdentifier.Identifier |
|
| KeywordOrIdentifier.Keyword |
|
| KeywordOrIdentifier.PartialVisitor<R> |
|
| KeywordOrIdentifier.Visitor<R> |
|
| KeywordPattern |
|
| KeywordPatterns |
|
| Keywords |
|
| Kvpair |
|
| Kwarg |
|
| KwargOrDoubleStarred |
|
| KwargOrDoubleStarred.DoubleStarred |
|
| KwargOrDoubleStarred.Kwarg |
|
| KwargOrDoubleStarred.PartialVisitor<R> |
|
| KwargOrDoubleStarred.Visitor<R> |
|
| KwargOrStarred |
|
| KwargOrStarred.Kwarg |
|
| KwargOrStarred.PartialVisitor<R> |
|
| KwargOrStarred.Starred |
|
| KwargOrStarred.Visitor<R> |
|
| Label |
Either a vertex or edge label
|
| Label.Edge |
|
| Label.PartialVisitor<R> |
|
| Label.Vertex |
|
| Label.Visitor<R> |
|
| LabeledStatement |
|
| LabeledStatementNoShortIf |
|
| Lambda |
A function abstraction (lambda)
|
| Lambda |
An anonymous function.
|
| Lambda |
|
| LambdaBody |
|
| LambdaBody.Block |
|
| LambdaBody.Expression |
|
| LambdaBody.PartialVisitor<R> |
|
| LambdaBody.Visitor<R> |
|
| LambdaExpression |
A lambda expression
|
| LambdaExpression |
|
| LambdaKwds |
|
| LambdaParameter |
|
| LambdaParameter_Normal |
|
| LambdaParameter.Normal |
|
| LambdaParameter.PartialVisitor<R> |
|
| LambdaParameter.VariableArity |
|
| LambdaParameter.Visitor<R> |
|
| LambdaParameters |
|
| LambdaParameters |
|
| LambdaParameters.PartialVisitor<R> |
|
| LambdaParameters.Single |
|
| LambdaParameters.Tuple |
|
| LambdaParameters.Visitor<R> |
|
| LambdaParameterType |
|
| LambdaParameterType.PartialVisitor<R> |
|
| LambdaParameterType.Type |
|
| LambdaParameterType.Var |
|
| LambdaParameterType.Visitor<R> |
|
| LambdaParamMaybeDefault |
|
| LambdaParamNoDefault |
|
| LambdaParamWithDefault |
|
| LambdaSlashNoDefault |
|
| LambdaSlashWithDefault |
|
| LambdaStarEtc |
|
| LambdaStarEtc.Kwds |
|
| LambdaStarEtc.ParamMaybeDefault |
|
| LambdaStarEtc.ParamNoDefault |
|
| LambdaStarEtc.PartialVisitor<R> |
|
| LambdaStarEtc.Star |
|
| LambdaStarEtc.Visitor<R> |
|
| LangStrings |
A convenience type which provides at most one string value per language, and optionally a value without a language
|
| LangTag |
|
| Language |
A named language together with language-specific constraints
|
| Language |
Language constraints and reserved words for Haskell
|
| Language |
Language constraints and reserved words for Java
|
| Language |
Language constraints and reserved words for Lisp (covering Clojure, Emacs Lisp, Common Lisp, and Scheme)
|
| Language |
|
| Language |
Language constraints and reserved words for Python 3
|
| Language |
Language constraints and reserved words for Scala
|
| Language |
Language constraints for W3C SHACL
|
| Language |
Language constraints based on TinkerPop Graph.Features
|
| LanguageConstraints |
A set of constraints on valid type and term expressions, characterizing a language
|
| LanguageName |
The unique name of a language
|
| Languages |
Language constraints for Hydra Core
|
| LanguageTag |
A BCP47 language tag
|
| Last |
Returns the last element of a list.
|
| Lazy<T> |
A memoizing supplier that evaluates its value at most once.
|
| LazyGraph<V> |
A graph which does not assume that vertex or edge ids are unique.
|
| LeftHandSide |
|
| LeftHandSide.ArrayAccess |
|
| LeftHandSide.ExpressionName |
|
| LeftHandSide.FieldAccess |
|
| LeftHandSide.PartialVisitor<R> |
|
| LeftHandSide.Visitor<R> |
|
| Lefts |
Extract all Left values from a list of Eithers.
|
| Length |
Returns the length of a list.
|
| Length |
Returns the length of a string.
|
| Let |
A set of (possibly recursive) 'let' bindings together with a body in which they are bound
|
| LetBinding |
A single binding in a let expression
|
| LetBinding.Destructuring |
A destructuring binding
|
| LetBinding.PartialVisitor<R> |
|
| LetBinding.Simple |
A simple name-value binding
|
| LetBinding.Visitor<R> |
|
| LetExpression |
A 'let' expression
|
| LetExpression |
Local variable bindings.
|
| LetKind |
The kind of let binding
|
| LetKind.Parallel |
|
| LetKind.PartialVisitor<R> |
|
| LetKind.Recursive |
|
| LetKind.Sequential |
|
| LetKind.Visitor<R> |
|
| LetQuery |
|
| Lexical |
A module for lexical operations over graphs.
|
| Libraries |
A registry of all of the primitive functions available in Hydra-Java.
|
| Library |
A library of primitive functions
|
| LiftLambdaAboveLetTestCase |
A test case which lifts lambda abstractions above let expressions and compares the result with the expected term
|
| Limit |
|
| Lines |
Splits a string into lines by breaking at newline characters.
|
| List |
|
| Listcomp |
|
| ListComprehension |
|
| ListFeatures |
List functionality
|
| ListFunctionFeatures |
List functions
|
| ListLiteral |
|
| ListLiteral |
A list literal: '(1 2 3) or (list 1 2 3)
|
| ListOperatorExpression |
|
| ListOperatorExpression.PartialVisitor<R> |
|
| ListOperatorExpression.Range |
|
| ListOperatorExpression.Single |
|
| ListOperatorExpression.Visitor<R> |
|
| ListOperatorExpressionOrPropertyLookup |
|
| ListOperatorExpressionOrPropertyLookup.List |
|
| ListOperatorExpressionOrPropertyLookup.PartialVisitor<R> |
|
| ListOperatorExpressionOrPropertyLookup.Property |
|
| ListOperatorExpressionOrPropertyLookup.Visitor<R> |
|
| ListPredicateExpression |
|
| Lists |
DSL interface providing list primitive operations.
|
| Lists |
Evaluation-level implementations of List functions for the Hydra interpreter.
|
| Lit |
|
| Lit.Boolean_ |
|
| Lit.Byte_ |
|
| Lit.Bytes |
|
| Lit.Char |
|
| Lit.Double_ |
|
| Lit.Float_ |
|
| Lit.Int |
|
| Lit.Long_ |
|
| Lit.Null |
|
| Lit.PartialVisitor<R> |
|
| Lit.Short_ |
|
| Lit.String_ |
|
| Lit.Symbol |
|
| Lit.Unit |
|
| Lit.Visitor<R> |
|
| Literal |
A term constant; an instance of a literal type
|
| Literal |
|
| Literal |
A literal value
|
| Literal |
|
| Literal |
|
| Literal |
A Lisp literal value
|
| Literal |
A value such as a string, number, or date
|
| Literal.Binary |
A binary literal
|
| Literal.Boolean_ |
A boolean literal
|
| Literal.Boolean_ |
|
| Literal.Boolean_ |
|
| Literal.Boolean_ |
A boolean literal (dialect-specific rendering)
|
| Literal.BooleanLiteral |
|
| Literal.Char |
A character literal
|
| Literal.Character_ |
|
| Literal.Character_ |
A character literal
|
| Literal.Double_ |
A double-precision floating point literal
|
| Literal.Float_ |
A floating-point literal
|
| Literal.Float_ |
A single-precision floating point literal
|
| Literal.Float_ |
A floating-point literal
|
| Literal.FloatingPoint |
|
| Literal.Int |
A 32-bit integer literal
|
| Literal.Integer_ |
An integer literal
|
| Literal.Integer_ |
An arbitrary-precision integer literal
|
| Literal.Integer_ |
|
| Literal.Integer_ |
An integer literal
|
| Literal.Keyword |
A keyword literal
|
| Literal.List |
|
| Literal.Map |
|
| Literal.Nil |
Nil/null/empty list (dialect-specific rendering)
|
| Literal.Null |
|
| Literal.Null |
|
| Literal.Number_ |
|
| Literal.NumericLiteral |
|
| Literal.PartialVisitor<R> |
|
| Literal.PartialVisitor<R> |
|
| Literal.PartialVisitor<R> |
|
| Literal.PartialVisitor<R> |
|
| Literal.PartialVisitor<R> |
|
| Literal.PartialVisitor<R> |
|
| Literal.RdfLiteral |
|
| Literal.String_ |
A string literal
|
| Literal.String_ |
|
| Literal.String_ |
A string literal
|
| Literal.String_ |
|
| Literal.String_ |
A string literal
|
| Literal.Symbol |
A quoted symbol literal
|
| Literal.Visitor<R> |
|
| Literal.Visitor<R> |
|
| Literal.Visitor<R> |
|
| Literal.Visitor<R> |
|
| Literal.Visitor<R> |
|
| Literal.Visitor<R> |
|
| LiteralExpression |
|
| LiteralExpression.Complex |
|
| LiteralExpression.False |
|
| LiteralExpression.None |
|
| LiteralExpression.Number_ |
|
| LiteralExpression.PartialVisitor<R> |
|
| LiteralExpression.String_ |
|
| LiteralExpression.True |
|
| LiteralExpression.Visitor<R> |
|
| LiteralExpressionOrAttribute |
|
| LiteralExpressionOrAttribute.Attribute |
|
| LiteralExpressionOrAttribute.Literal |
|
| LiteralExpressionOrAttribute.PartialVisitor<R> |
|
| LiteralExpressionOrAttribute.Visitor<R> |
|
| LiteralFeatures |
Various types of literal values
|
| LiteralPattern |
A pattern matching a literal value
|
| Literals |
DSL functions for working with literal values.
|
| Literals |
DSL interface providing literal primitive operations for type conversions and parsing/showing values.
|
| Literals |
Conversion functions for literal values.
|
| LiteralType |
Any of a fixed set of literal types, also called atomic types, base types, primitive types, or type constants
|
| LiteralType.Binary |
The type of a binary (byte string) value
|
| LiteralType.Boolean_ |
The type of a boolean (true/false) value
|
| LiteralType.Float_ |
The type of a floating-point value
|
| LiteralType.Integer_ |
The type of an integer value
|
| LiteralType.PartialVisitor<R> |
|
| LiteralType.String_ |
The type of a string value
|
| LiteralType.Visitor<R> |
|
| LiteralTypes |
DSL utilities for working with literal types.
|
| LiteralVariant |
The identifier of a literal constructor
|
| LiteralVariant.Binary |
|
| LiteralVariant.Boolean_ |
|
| LiteralVariant.Float_ |
|
| LiteralVariant.Integer_ |
|
| LiteralVariant.PartialVisitor<R> |
|
| LiteralVariant.String_ |
|
| LiteralVariant.Visitor<R> |
|
| LList<X> |
A simple tail-sharing linked list.
|
| LoadCSVFunctionFeatures |
Load CSV functions
|
| LocalBinding |
A local binding
|
| LocalBinding.PartialVisitor<R> |
|
| LocalBinding.Signature |
A type signature
|
| LocalBinding.Value |
A value binding
|
| LocalBinding.Visitor<R> |
|
| LocalBindings |
A collection of local bindings
|
| LocalVariableDeclaration |
|
| LocalVariableDeclarationStatement |
|
| LocalVariableType |
|
| LocalVariableType.PartialVisitor<R> |
|
| LocalVariableType.Type |
|
| LocalVariableType.Var |
|
| LocalVariableType.Visitor<R> |
|
| Log |
Computes the natural logarithm.
|
| LogarithmicFunctionFeatures |
Logarithmic functions
|
| LogBase |
Computes the logarithm with a specified base.
|
| Logic |
DSL interface providing logic primitive operations.
|
| Logic |
Evaluation-level implementations of Logic functions for the Hydra interpreter.
|
| LogicalFeatures |
Logical operations
|
| Long_ |
|
| Lookup |
Looks up a value by key.
|
| Lt |
Tests if the first value is less than the second.
|
| Lte |
Tests if the first value is less than or equal to the second.
|
| MacroDefinition |
A macro definition.
|
| Map |
Map a function over the Right side of an Either value.
|
| Map |
Applies a function to each element of a list, returning a new list of results.
|
| Map |
Maps a function over a flow.
|
| Map |
Maps a function over a flow.
|
| Map |
Maps a function over all elements in a set.
|
| Map |
|
| MapEntry |
A key-value pair in a map literal
|
| MapEntry |
|
| MapEntry.Key |
|
| MapEntry.PartialVisitor<R> |
|
| MapEntry.Value |
|
| MapEntry.Visitor<R> |
|
| MapKey |
|
| MapKey.Collection |
|
| MapKey.Identifier |
|
| MapKey.Keyword |
|
| MapKey.Map |
|
| MapKey.Numeric |
|
| MapKey.PartialVisitor<R> |
|
| MapKey.Set |
|
| MapKey.String_ |
|
| MapKey.TraversalDirection |
|
| MapKey.TraversalToken |
|
| MapKey.Visitor<R> |
|
| MapKeys |
Maps a flow function over map keys.
|
| MapList |
Map a function that may fail over a list, collecting results or returning the first error.
|
| MapLiteral |
|
| MapLiteral |
A map/dictionary literal.
|
| MapMaybe |
Map a function that may fail over a Maybe, collecting results or returning the first error.
|
| MapMaybe |
Maps a flow function over Maybe.
|
| MapperBase |
A base class for simple functional mappers with exceptions (specific to Java).
|
| MapperBase.MapperException |
Exception thrown by mapper operations when invalid data is encountered.
|
| Mapping |
Term decoders for hydra.pg.mapping
|
| Mapping |
Term encoders for hydra.pg.mapping
|
| MappingPattern |
|
| Mappings |
Mappings from property graph schemas to SHACL shapes graphs, and from property graph data to RDF graphs
|
| Maps |
DSL interface providing map primitive operations.
|
| Maps |
Evaluation-level implementations of Map functions for the Hydra interpreter.
|
| MapSet |
Map a function that may fail over a set, collecting results or returning the first error.
|
| MapType |
A map type
|
| MarkerAnnotation |
|
| Match |
|
| Matches |
Checks whether an entire string matches a regex pattern.
|
| MatchFeatures |
Match queries
|
| MatchOrCreate |
|
| MatchOrCreate.Create |
|
| MatchOrCreate.Match |
|
| MatchOrCreate.PartialVisitor<R> |
|
| MatchOrCreate.Visitor<R> |
|
| MatchQuery |
|
| MatchStatement |
|
| Math |
DSL interface providing mathematical primitive operations.
|
| Math_ |
Evaluation-level implementations of Math functions for the Hydra interpreter.
|
| Max |
Returns the maximum of two values.
|
| Max |
Returns the maximum of two numbers.
|
| Maybe |
Pattern matches with a default.
|
| Maybe<T> |
A Hydra binary labeled union type, similar to java.util.Optional.
|
| Maybes |
DSL interface providing Maybe/Optional primitive operations for working with optional values.
|
| Maybes |
Evaluation-level implementations of Maybe functions for the Hydra interpreter.
|
| MaybeSequencePattern |
|
| MaybeStarPattern |
|
| MaybeStarPattern.PartialVisitor<R> |
|
| MaybeStarPattern.Pattern |
|
| MaybeStarPattern.Star |
|
| MaybeStarPattern.Visitor<R> |
|
| Member |
|
| Member |
Checks if an element is in a set.
|
| Member |
Checks if an element is in a set.
|
| Member_Data |
|
| Member_Data.Object_ |
|
| Member_Data.PartialVisitor<R> |
|
| Member_Data.Pkg |
|
| Member_Data.Visitor<R> |
|
| Member_Type |
|
| Member.PartialVisitor<R> |
|
| Member.Self |
|
| Member.Term |
|
| Member.TermParam |
|
| Member.Type |
|
| Member.TypeParam |
|
| Member.Visitor<R> |
|
| Merge |
|
| MergeAction |
|
| MergeFeatures |
Merge operations
|
| Merging |
Utilities for combining multiple vertex or edge types into a single "merged" vertex or edge type,
and correspondingly encoding and decoding vertices and edges of these types.
|
| Merging.IdAdapters<T,V> |
A helper object which defines merged vertex and edge id types, and a value coder for each vertex and edge label.
|
| Meta |
String representations of hydra.meta types
|
| MethodBody |
|
| MethodBody.Block |
|
| MethodBody.None |
|
| MethodBody.PartialVisitor<R> |
|
| MethodBody.Visitor<R> |
|
| MethodDeclaration |
|
| MethodDeclarator |
|
| MethodHeader |
|
| MethodInvocation |
|
| MethodInvocation_Complex |
|
| MethodInvocation_Header |
|
| MethodInvocation_Header.Complex |
|
| MethodInvocation_Header.PartialVisitor<R> |
|
| MethodInvocation_Header.Simple |
|
| MethodInvocation_Header.Visitor<R> |
|
| MethodInvocation_Variant |
|
| MethodInvocation_Variant.Expression |
|
| MethodInvocation_Variant.PartialVisitor<R> |
|
| MethodInvocation_Variant.Primary |
|
| MethodInvocation_Variant.Super |
|
| MethodInvocation_Variant.Type |
|
| MethodInvocation_Variant.TypeSuper |
|
| MethodInvocation_Variant.Visitor<R> |
|
| MethodModifier |
|
| MethodModifier.Abstract |
|
| MethodModifier.Annotation |
|
| MethodModifier.Final |
|
| MethodModifier.Native |
|
| MethodModifier.PartialVisitor<R> |
|
| MethodModifier.Private |
|
| MethodModifier.Protected |
|
| MethodModifier.Public |
|
| MethodModifier.Static |
|
| MethodModifier.Strictfb |
|
| MethodModifier.Synchronized |
|
| MethodModifier.Visitor<R> |
|
| MethodName |
|
| MethodReference |
|
| MethodReference_Array |
|
| MethodReference_Expression |
|
| MethodReference_New |
|
| MethodReference_Primary |
|
| MethodReference_ReferenceType |
|
| MethodReference_Super |
|
| MethodReference.Array |
|
| MethodReference.Expression |
|
| MethodReference.New |
|
| MethodReference.PartialVisitor<R> |
|
| MethodReference.Primary |
|
| MethodReference.ReferenceType |
|
| MethodReference.Super |
|
| MethodReference.Visitor<R> |
|
| Min |
Returns the minimum of two values.
|
| Min |
Returns the minimum of two numbers.
|
| Mod |
|
| Mod |
Computes the modulo of two integers.
|
| Mod_Annot |
|
| Mod_Private |
|
| Mod_Protected |
|
| Mod.Abstract |
|
| Mod.Annot |
|
| Mod.Case |
|
| Mod.Contravariant |
|
| Mod.Covariant |
|
| Mod.Final |
|
| Mod.Implicit |
|
| Mod.Infix |
|
| Mod.Inline |
|
| Mod.Lazy |
|
| Mod.Opaque |
|
| Mod.Open |
|
| Mod.Override_ |
|
| Mod.PartialVisitor<R> |
|
| Mod.Private |
|
| Mod.Protected |
|
| Mod.Sealed |
|
| Mod.Super |
|
| Mod.Transparent |
|
| Mod.Using |
|
| Mod.ValParam |
|
| Mod.VarParam |
|
| Mod.Visitor<R> |
|
| Model |
Term decoders for hydra.json.model
|
| Model |
Term decoders for hydra.pg.model
|
| Model |
DSL functions for hydra.json.model
|
| Model |
Term encoders for hydra.json.model
|
| Model |
Term encoders for hydra.pg.model
|
| ModularCompilationUnit |
|
| Module |
Term decoders for hydra.module
|
| Module |
DSL functions for hydra.module
|
| Module |
Term encoders for hydra.module
|
| Module |
A Haskell module
|
| Module |
|
| Module |
A logical collection of elements in the same namespace, having dependencies on zero or more other modules
|
| ModuleDeclaration |
|
| ModuleDeclaration |
A module/namespace declaration.
|
| ModuleDirective |
|
| ModuleDirective_ExportsOrOpens |
|
| ModuleDirective_Provides |
|
| ModuleDirective_Requires |
|
| ModuleDirective.Exports |
|
| ModuleDirective.Opens |
|
| ModuleDirective.PartialVisitor<R> |
|
| ModuleDirective.Provides |
|
| ModuleDirective.Requires |
|
| ModuleDirective.Uses |
|
| ModuleDirective.Visitor<R> |
|
| ModuleHead |
A module head
|
| ModuleName |
A module name
|
| ModuleName |
|
| Mul |
Performs multiplication on two numbers.
|
| MultiElementGroup |
|
| MultiElementOneOf |
|
| MultiPartQuery |
|
| MultiplicativeExpression |
|
| MultiplicativeExpression_Binary |
|
| MultiplicativeExpression.Divide |
|
| MultiplicativeExpression.Mod |
|
| MultiplicativeExpression.PartialVisitor<R> |
|
| MultiplicativeExpression.Times |
|
| MultiplicativeExpression.Unary |
|
| MultiplicativeExpression.Visitor<R> |
|
| MultiplyDivideModuloExpression |
|
| MultiplyDivideModuloOperator |
|
| MultiplyDivideModuloOperator.Divide |
|
| MultiplyDivideModuloOperator.Modulo |
|
| MultiplyDivideModuloOperator.Multiply |
|
| MultiplyDivideModuloOperator.PartialVisitor<R> |
|
| MultiplyDivideModuloOperator.Visitor<R> |
|
| MultiplyDivideModuloRightHandSide |
|
| Name |
A unique identifier in some context; a string-valued key
|
| Name |
A name
|
| Name |
|
| Name |
|
| Name |
|
| Name.Anonymous |
|
| Name.Implicit |
An implicit name
|
| Name.Indeterminate |
|
| Name.Normal |
A normal name
|
| Name.Parens |
A parenthesized name
|
| Name.PartialVisitor<R> |
|
| Name.PartialVisitor<R> |
|
| Name.Value |
|
| Name.Visitor<R> |
|
| Name.Visitor<R> |
|
| NamedExpression |
|
| NamedExpression.Assignment |
|
| NamedExpression.PartialVisitor<R> |
|
| NamedExpression.Simple |
|
| NamedExpression.Visitor<R> |
|
| NamedIndividual |
|
| NameOrAttribute |
|
| NamePart |
A component of a qualified name
|
| Names |
Java naming constants and package name utilities
|
| Names |
Python naming utilities: encoding Hydra names as Python names
|
| Names |
Namespaces and primitive names for the Hydra standard library
|
| Names |
Functions for working with qualified names.
|
| Namespace |
A prefix for element names
|
| NamespaceName |
A namespace or package name
|
| Namespaces<N> |
A mapping from namespaces to values of type n, with a focus on one namespace
|
| Negate |
Negates a number.
|
| NegativeDataPropertyAssertion |
|
| NegativeInteger |
|
| NegativeObjectPropertyAssertion |
|
| NestedTermAnnotationError |
A term annotation directly wrapping another term annotation; annotations should be merged (optional)
|
| NestedTraversal |
|
| NestedTraversal.Anonymous |
|
| NestedTraversal.Chained |
|
| NestedTraversal.PartialVisitor<R> |
|
| NestedTraversal.Root |
|
| NestedTraversal.Visitor<R> |
|
| NestedTraversalArgument |
|
| NestedTypeAnnotationError |
A type annotation directly wrapping another type annotation; annotations should be merged (optional)
|
| NilStyle |
The style of nil/null in a dialect
|
| NilStyle.EmptyList |
|
| NilStyle.Nil |
|
| NilStyle.PartialVisitor<R> |
|
| NilStyle.Visitor<R> |
|
| NMTOKEN |
|
| Node |
|
| Node |
A YAML node (value)
|
| Node |
A node in a query expression; it may be a term, a variable, or a wildcard
|
| Node.Bnode |
|
| Node.Iri |
|
| Node.Literal |
|
| Node.Mapping |
A mapping from nodes to nodes
|
| Node.PartialVisitor<R> |
|
| Node.PartialVisitor<R> |
|
| Node.PartialVisitor<R> |
|
| Node.Scalar |
A scalar value
|
| Node.Sequence |
A sequence of nodes
|
| Node.Term |
A graph term; an expression which is valid in the graph being matched
|
| Node.Variable |
A query variable, not to be confused with a variable term
|
| Node.Visitor<R> |
|
| Node.Visitor<R> |
|
| Node.Visitor<R> |
|
| Node.Wildcard |
An anonymous variable which we do not care to join across patterns
|
| NodeConstraint |
|
| NodeConstraint_Sequence2 |
|
| NodeConstraint_Sequence3 |
|
| NodeConstraint_Sequence4 |
|
| NodeConstraint_Sequence5 |
|
| NodeConstraint.ListOfXsFacet |
|
| NodeConstraint.PartialVisitor<R> |
|
| NodeConstraint.Sequence |
|
| NodeConstraint.Sequence2 |
|
| NodeConstraint.Sequence3 |
|
| NodeConstraint.Sequence4 |
|
| NodeConstraint.Sequence5 |
|
| NodeConstraint.Visitor<R> |
|
| NoDefaultStarAnnotationStarEtc |
|
| NoDefaultStarEtc |
|
| NodeKind |
|
| NodeKind.BlankNode |
A blank node
|
| NodeKind.BlankNodeOrIri |
A blank node or an IRI
|
| NodeKind.BlankNodeOrLiteral |
A blank node or a literal
|
| NodeKind.Iri |
An IRI
|
| NodeKind.IriOrLiteral |
An IRI or a literal
|
| NodeKind.Literal |
A literal
|
| NodeKind.PartialVisitor<R> |
|
| NodeKind.Visitor<R> |
|
| NodeLabel |
|
| NodeLabels |
|
| NodePattern |
|
| NodePatternChain |
|
| NodePatternFeatures |
Node patterns
|
| NodeShape |
A SHACL node shape.
|
| NonArithmeticOperatorExpression |
|
| NonComparableMapKeyTypeError |
A map type whose key type is or directly contains a function type, which cannot be compared for equality
|
| NonComparableSetElementTypeError |
A set type whose element type is or directly contains a function type, which cannot be compared for equality
|
| NonLiteralKind |
|
| NonLiteralKind.BNODE |
|
| NonLiteralKind.IRI |
|
| NonLiteralKind.NONLITERAL |
|
| NonLiteralKind.PartialVisitor<R> |
|
| NonLiteralKind.Visitor<R> |
|
| NonNegativeInteger |
|
| NonPositiveInteger |
|
| NormalAnnotation |
|
| NormalClassDeclaration |
|
| NormalInterfaceDeclaration |
|
| NormalizedString |
|
| NormalizeTypeVariablesTestCase |
A test case which normalizes type variables in a term (renaming them to t0, t1, t2, etc.) and compares the result with the expected term
|
| Not |
Performs logical negation on a boolean value.
|
| NotAForallTypeError |
A type that is not a forall type when type arguments are being applied
|
| NotAFunctionTypeError |
A type that is not a function type when one was expected in an application
|
| NOTATION |
|
| NotExpression |
|
| NotExpression |
Logical negation: (not expr)
|
| NotStartAction |
|
| NotStartAction_ShapeExprDecl |
|
| NotStartAction_ShapeExprDecl_Alts |
|
| NotStartAction_ShapeExprDecl_Alts.EXTERNAL |
|
| NotStartAction_ShapeExprDecl_Alts.PartialVisitor<R> |
|
| NotStartAction_ShapeExprDecl_Alts.ShapeExpression |
|
| NotStartAction_ShapeExprDecl_Alts.Visitor<R> |
|
| NotStartAction.PartialVisitor<R> |
|
| NotStartAction.ShapeExprDecl |
|
| NotStartAction.Start |
|
| NotStartAction.Visitor<R> |
|
| Nub |
Removes duplicate elements.
|
| Null |
Checks if a list is empty.
|
| Null |
Checks if a map is empty (null in Haskell terminology).
|
| Null |
Checks if a set is empty (null check).
|
| Null |
Determines whether a string is empty (null check).
|
| NullFeatures |
IS NULL / IS NOT NULL checks
|
| NullPredicateExpression |
|
| Number_ |
|
| Number_.Float_ |
|
| Number_.Integer_ |
|
| Number_.PartialVisitor<R> |
|
| Number_.Visitor<R> |
|
| NumberLiteral |
|
| NumberLiteral.Double_ |
|
| NumberLiteral.Integer_ |
|
| NumberLiteral.PartialVisitor<R> |
|
| NumberLiteral.Visitor<R> |
|
| NumericFacet |
|
| NumericFacet_Sequence |
|
| NumericFacet_Sequence2 |
|
| NumericFacet.PartialVisitor<R> |
|
| NumericFacet.Sequence |
|
| NumericFacet.Sequence2 |
|
| NumericFacet.Visitor<R> |
|
| NumericFunctionFeatures |
Numeric functions
|
| NumericLength |
|
| NumericLength.FRACTIONDIGITS |
|
| NumericLength.PartialVisitor<R> |
|
| NumericLength.TOTALDIGITS |
|
| NumericLength.Visitor<R> |
|
| NumericLiteral |
|
| NumericLiteral |
|
| NumericLiteral.Decimal |
|
| NumericLiteral.Double_ |
|
| NumericLiteral.Float_ |
|
| NumericLiteral.Integer_ |
|
| NumericLiteral.Integer_ |
|
| NumericLiteral.PartialVisitor<R> |
|
| NumericLiteral.PartialVisitor<R> |
|
| NumericLiteral.Visitor<R> |
|
| NumericLiteral.Visitor<R> |
|
| NumericRange |
|
| NumericRange.MAXEXCLUSIVE |
|
| NumericRange.MAXINCLUSIVE |
|
| NumericRange.MINEXCLUSIVE |
|
| NumericRange.MININCLUSIVE |
|
| NumericRange.PartialVisitor<R> |
|
| NumericRange.Visitor<R> |
|
| NumericType |
|
| NumericType.FloatingPoint |
|
| NumericType.Integral |
|
| NumericType.PartialVisitor<R> |
|
| NumericType.Visitor<R> |
|
| NumericTypeArray |
|
| NumericTypeArray.Array |
|
| NumericTypeArray.PartialVisitor<R> |
|
| NumericTypeArray.Simple |
|
| NumericTypeArray.Visitor<R> |
|
| ObjectAllValuesFrom |
|
| ObjectComplementOf |
|
| ObjectExactCardinality |
See https://www.w3.org/TR/owl2-syntax/#Exact_Cardinality
|
| ObjectHasSelf |
|
| ObjectHasValue |
|
| ObjectIntersectionOf |
|
| ObjectMaxCardinality |
See https://www.w3.org/TR/owl2-syntax/#Maximum_Cardinality
|
| ObjectMinCardinality |
See https://www.w3.org/TR/owl2-syntax/#Minimum_Cardinality
|
| ObjectOneOf |
|
| ObjectProperty |
See https://www.w3.org/TR/owl2-syntax/#Object_Properties
|
| ObjectPropertyAssertion |
|
| ObjectPropertyAxiom |
|
| ObjectPropertyAxiom.AsymmetricObjectProperty |
|
| ObjectPropertyAxiom.DisjointObjectProperties |
|
| ObjectPropertyAxiom.EquivalentObjectProperties |
|
| ObjectPropertyAxiom.FunctionalObjectProperty |
|
| ObjectPropertyAxiom.InverseFunctionalObjectProperty |
|
| ObjectPropertyAxiom.InverseObjectProperties |
|
| ObjectPropertyAxiom.IrreflexiveObjectProperty |
|
| ObjectPropertyAxiom.ObjectPropertyDomain |
|
| ObjectPropertyAxiom.ObjectPropertyRange |
|
| ObjectPropertyAxiom.PartialVisitor<R> |
|
| ObjectPropertyAxiom.ReflexiveObjectProperty |
|
| ObjectPropertyAxiom.SubObjectPropertyOf |
|
| ObjectPropertyAxiom.SymmetricObjectProperty |
|
| ObjectPropertyAxiom.TransitiveObjectProperty |
|
| ObjectPropertyAxiom.Visitor<R> |
|
| ObjectPropertyDomain |
See https://www.w3.org/TR/owl2-syntax/#Object_Property_Domain
|
| ObjectPropertyExpression |
|
| ObjectPropertyExpression.InverseObject |
|
| ObjectPropertyExpression.Object_ |
|
| ObjectPropertyExpression.PartialVisitor<R> |
|
| ObjectPropertyExpression.Visitor<R> |
|
| ObjectPropertyRange |
See https://www.w3.org/TR/owl2-syntax/#Object_Property_Range
|
| ObjectSomeValuesFrom |
|
| ObjectUnionOf |
|
| Odd |
Determines whether an integer is odd.
|
| OneOfTripleExpr |
|
| OneOfTripleExpr.GroupTripleExpr |
|
| OneOfTripleExpr.MultiElementOneOf |
|
| OneOfTripleExpr.PartialVisitor<R> |
|
| OneOfTripleExpr.Visitor<R> |
|
| Ontology |
|
| Op |
An operator symbol
|
| OpenSequencePattern |
|
| Operator |
An operator
|
| Operator.Backtick |
A function used as an infix operator
|
| Operator.Normal |
A normal infix operator
|
| Operator.PartialVisitor<R> |
|
| Operator.Visitor<R> |
|
| Operators |
AST operators for Haskell
|
| OpExpr |
An operator expression
|
| OptionalStringArgumentAndNestedTraversal |
|
| OptionalTraversalScopeArgumentAndIntegerArgument |
|
| OptionalTraversalScopeArgumentAndStringArgument |
|
| OptionArgs |
|
| OptionArgs.MergeMap |
|
| OptionArgs.MergeTraversal |
|
| OptionArgs.ObjectTraversal |
|
| OptionArgs.PartialVisitor<R> |
|
| OptionArgs.PredicateTraversal |
|
| OptionArgs.Traversal |
|
| OptionArgs.Visitor<R> |
|
| Or |
Performs logical OR on two boolean values.
|
| Order |
|
| OrderingIsomorphism<A> |
|
| OrdinaryCompilationUnit |
|
| OrdinaryConstructor |
An ordinary (positional) data constructor
|
| OrExpression |
|
| OrExpression |
Logical or: (or expr1 expr2 ...)
|
| OrPattern |
|
| OtherError |
Any other error
|
| Package_ |
A package, which is a named collection of modules with metadata and dependencies
|
| PackageDeclaration |
|
| PackageModifier |
|
| PackageName |
|
| PackageName |
The unique name of a package, e.g.
|
| PackageOrTypeName |
|
| Packaging |
DSL functions for hydra.error.packaging
|
| Packaging |
DSL functions for hydra.packaging
|
| Packaging |
Validation functions for modules and packages
|
| Padding |
Left and right padding for an operator
|
| PageRankConstants |
|
| PageRankConstants.Edges |
|
| PageRankConstants.PartialVisitor<R> |
|
| PageRankConstants.PropertyName |
|
| PageRankConstants.Times |
|
| PageRankConstants.Visitor<R> |
|
| Pair<A,B> |
A simple class for pairs in Java.
|
| Pairs |
DSL interface providing pair primitive operations.
|
| Pairs |
Evaluation-level implementations of Pair functions for the Hydra interpreter.
|
| PairType |
A type which pairs a 'first' type and a 'second' type
|
| Param |
|
| Parameter |
|
| Parameter.Integer_ |
|
| Parameter.PartialVisitor<R> |
|
| Parameter.Symbolic |
|
| Parameter.Visitor<R> |
|
| Parameters |
|
| Parameters.ParamNoDefault |
|
| Parameters.ParamWithDefault |
|
| Parameters.PartialVisitor<R> |
|
| Parameters.SlashNoDefault |
|
| Parameters.SlashWithDefault |
|
| Parameters.StarEtc |
|
| Parameters.Visitor<R> |
|
| ParamMaybeDefault |
|
| ParamNoDefault |
|
| ParamNoDefaultParameters |
|
| ParamNoDefaultStarAnnotation |
|
| ParamStarAnnotation |
|
| ParamWithDefault |
|
| ParamWithDefaultParameters |
|
| ParenthesizedExpression |
|
| ParseError |
An error which occurred while parsing
|
| Parser |
JSON parser using Hydra parser combinators
|
| Parser<A> |
A parser which consumes characters from a string and produces a value
|
| ParseResult<A> |
The result of a parse operation
|
| ParseResult.Failure<A> |
A failed parse, with an error message and the remaining input
|
| ParseResult.PartialVisitor<A,R> |
|
| ParseResult.Success<A> |
A successful parse, with a value and the remaining unparsed input
|
| ParseResult.Visitor<A,R> |
|
| Parsers |
General-purpose parser combinators
|
| ParserTestCase<A> |
A test case which parses an input string and compares the result with an expected value
|
| ParseSuccess<A> |
A successful parse result
|
| Parsing |
Term decoders for hydra.parsing
|
| Parsing |
DSL functions for hydra.parsing
|
| Parsing |
Term encoders for hydra.parsing
|
| PartialComparisonExpression |
|
| Partition |
Partitions a list based on a predicate.
|
| PartitionEithers |
Partition a list of Eithers into separate lists of Left and Right values.
|
| Pat |
|
| Pat_Alternative |
|
| Pat_Bind |
|
| Pat_Extract |
|
| Pat_ExtractInfix |
|
| Pat_Given |
|
| Pat_Interpolate |
|
| Pat_Macro |
|
| Pat_Repeated |
|
| Pat_Tuple |
|
| Pat_Typed |
|
| Pat_Var |
|
| Pat_Xml |
|
| Pat.Alternative |
|
| Pat.Bind |
|
| Pat.Extract |
|
| Pat.ExtractInfix |
|
| Pat.Given |
|
| Pat.Interpolate |
|
| Pat.Macro |
|
| Pat.PartialVisitor<R> |
|
| Pat.Repeated |
|
| Pat.SeqWildcard |
|
| Pat.Tuple |
|
| Pat.Typed |
|
| Pat.Var |
|
| Pat.Visitor<R> |
|
| Pat.Wildcard |
|
| Pat.Xml |
|
| Path |
A query path
|
| Path.Inverse |
A path given by the inverse of another path
|
| Path.PartialVisitor<R> |
|
| Path.Regex |
A path given by a regular expression quantifier applied to another path
|
| Path.Step |
A path given by a single step
|
| Path.Visitor<R> |
|
| PathEquation |
A declared equivalence between two abstract paths in a graph
|
| PathFeatures |
Path functions only found in OpenCypher
|
| Paths |
Term decoders for hydra.paths
|
| Paths |
DSL functions for hydra.paths
|
| Paths |
Term encoders for hydra.paths
|
| Paths |
Utilities for working with subterm steps and paths.
|
| Pattern |
|
| Pattern |
A pattern
|
| Pattern |
A pattern for use in case expressions or match forms
|
| Pattern |
A SHACL pattern.
|
| Pattern |
|
| Pattern |
A query pattern
|
| Pattern.Application |
An application pattern
|
| Pattern.As |
An 'as' pattern
|
| Pattern.As |
|
| Pattern.Conjunction |
The conjunction ('and') of several other patterns
|
| Pattern.Constructor |
A constructor pattern (for union/sum type matching)
|
| Pattern.Disjunction |
The disjunction (inclusive 'or') of several other patterns
|
| Pattern.Graph |
A pattern which matches within a named subgraph
|
| Pattern.List |
A list pattern
|
| Pattern.Literal |
A literal pattern
|
| Pattern.Literal |
A literal pattern
|
| Pattern.Name |
A name pattern
|
| Pattern.Negation |
The negation of another pattern
|
| Pattern.Or |
|
| Pattern.Parens |
A parenthesized pattern
|
| Pattern.PartialVisitor<R> |
|
| Pattern.PartialVisitor<R> |
|
| Pattern.PartialVisitor<R> |
|
| Pattern.PartialVisitor<R> |
|
| Pattern.Record |
A record pattern
|
| Pattern.Triple |
A subject/predicate/object pattern
|
| Pattern.Tuple |
A tuple pattern
|
| Pattern.Typed |
A typed pattern
|
| Pattern.Variable |
A variable pattern that binds the matched value
|
| Pattern.Visitor<R> |
|
| Pattern.Visitor<R> |
|
| Pattern.Visitor<R> |
|
| Pattern.Visitor<R> |
|
| Pattern.Wildcard |
A wildcard pattern
|
| Pattern.Wildcard |
A wildcard pattern matching anything
|
| PatternCaptureTarget |
|
| PatternComprehension |
|
| PatternElement |
|
| PatternElement.Chained |
|
| PatternElement.Parenthesized |
|
| PatternElement.PartialVisitor<R> |
|
| PatternElement.Visitor<R> |
|
| PatternElementChain |
|
| PatternField |
A pattern field
|
| PatternImplication |
A pattern which, if it matches in a given graph, implies that another pattern must also match.
|
| PatternPart |
|
| PatternPredicate |
|
| Patterns |
|
| Patterns.PartialVisitor<R> |
|
| Patterns.Pattern |
|
| Patterns.Sequence |
|
| Patterns.Visitor<R> |
|
| PatternWhere |
|
| PeerPressureConstants |
|
| PeerPressureConstants.Edges |
|
| PeerPressureConstants.PartialVisitor<R> |
|
| PeerPressureConstants.PropertyName |
|
| PeerPressureConstants.Times |
|
| PeerPressureConstants.Visitor<R> |
|
| Percent |
|
| PersistentMap<K,V> |
A persistent (immutable, structurally-shared) ordered map based on a red-black tree.
|
| PersistentSet<T> |
A persistent (immutable, structurally-shared) ordered set based on PersistentMap. |
| PgRdfEnvironment<V> |
The environment for property graph to RDF mapping
|
| Phantoms |
Term decoders for hydra.phantoms
|
| Phantoms |
Term encoders for hydra.phantoms
|
| Pi |
Returns the mathematical constant pi.
|
| Pkg |
|
| Pkg_Object |
|
| PlusOrMinus |
|
| PlusOrMinus.Minus |
|
| PlusOrMinus.PartialVisitor<R> |
|
| PlusOrMinus.Plus |
|
| PlusOrMinus.Visitor<R> |
|
| Plx |
|
| Plx.PartialVisitor<R> |
|
| Plx.Percent |
|
| Plx.PnLocalEsc |
|
| Plx.Visitor<R> |
|
| PnameLn |
|
| PnameNs |
|
| PnChars |
|
| PnChars.Minus |
|
| PnChars.PartialVisitor<R> |
|
| PnChars.PnCharsU |
|
| PnChars.Regex |
|
| PnChars.Visitor<R> |
|
| PnCharsBase |
|
| PnCharsBase.PartialVisitor<R> |
|
| PnCharsBase.Regex |
|
| PnCharsBase.Regex2 |
|
| PnCharsBase.Visitor<R> |
|
| PnCharsU |
|
| PnCharsU.Lowbar |
|
| PnCharsU.PartialVisitor<R> |
|
| PnCharsU.PnCharsBase |
|
| PnCharsU.Visitor<R> |
|
| PnLocal |
|
| PnLocal_Alts |
|
| PnLocal_Alts.Colon |
|
| PnLocal_Alts.PartialVisitor<R> |
|
| PnLocal_Alts.Plx |
|
| PnLocal_Alts.PnCharsU |
|
| PnLocal_Alts.Regex |
|
| PnLocal_Alts.Visitor<R> |
|
| PnLocal_Sequence_Option |
|
| PnLocal_Sequence_Option_Alts |
|
| PnLocal_Sequence_Option_Alts.Colon |
|
| PnLocal_Sequence_Option_Alts.PartialVisitor<R> |
|
| PnLocal_Sequence_Option_Alts.Plx |
|
| PnLocal_Sequence_Option_Alts.PnChars |
|
| PnLocal_Sequence_Option_Alts.Visitor<R> |
|
| PnLocal_Sequence_Option_ListOfAlts_Elmt |
|
| PnLocal_Sequence_Option_ListOfAlts_Elmt.Colon |
|
| PnLocal_Sequence_Option_ListOfAlts_Elmt.PartialVisitor<R> |
|
| PnLocal_Sequence_Option_ListOfAlts_Elmt.Period |
|
| PnLocal_Sequence_Option_ListOfAlts_Elmt.Plx |
|
| PnLocal_Sequence_Option_ListOfAlts_Elmt.PnChars |
|
| PnLocal_Sequence_Option_ListOfAlts_Elmt.Visitor<R> |
|
| PnLocalEsc |
|
| PnPrefix |
|
| PnPrefix_Sequence_Option |
|
| PnPrefix_Sequence_Option_Alts |
|
| PnPrefix_Sequence_Option_Alts.PartialVisitor<R> |
|
| PnPrefix_Sequence_Option_Alts.Period |
|
| PnPrefix_Sequence_Option_Alts.PnChars |
|
| PnPrefix_Sequence_Option_Alts.Visitor<R> |
|
| PopStringsArgument |
|
| PosArg |
|
| PosArg.Assignment |
|
| PosArg.Expression |
|
| PosArg.PartialVisitor<R> |
|
| PosArg.Starred |
|
| PosArg.Visitor<R> |
|
| PositionalPatterns |
|
| PositiveInteger |
|
| PostDecrementExpression |
|
| PostfixExpression |
|
| PostfixExpression.Name |
|
| PostfixExpression.PartialVisitor<R> |
|
| PostfixExpression.PostDecrement |
|
| PostfixExpression.PostIncrement |
|
| PostfixExpression.Primary |
|
| PostfixExpression.Visitor<R> |
|
| PostIncrementExpression |
|
| Pow |
Raises a number to a power.
|
| Power |
|
| PowerOfExpression |
|
| Precedence |
Operator precedence
|
| Precision |
Numeric precision: arbitrary precision, or precision to a specified number of bits
|
| Precision.Arbitrary |
Arbitrary precision
|
| Precision.Bits |
Precision to a specified number of bits
|
| Precision.PartialVisitor<R> |
|
| Precision.Visitor<R> |
|
| Pred |
Returns the predecessor of an integer.
|
| PreDecrementExpression |
|
| PredefString |
|
| Predicate |
|
| Predicate.Iri |
|
| Predicate.PartialVisitor<R> |
|
| Predicate.RdfType |
|
| Predicate.Visitor<R> |
|
| PredicateFunctionFeatures |
Predicate functions
|
| PredicateOrTraversal |
|
| PredicateOrTraversal.PartialVisitor<R> |
|
| PredicateOrTraversal.Predicate |
|
| PredicateOrTraversal.Traversal |
|
| PredicateOrTraversal.Visitor<R> |
|
| PredicateTraversalArgument |
|
| PrefixApplicationExpression |
A prefix expression
|
| PrefixDecl |
|
| PrefixedName |
|
| PrefixedName.PartialVisitor<R> |
|
| PrefixedName.PnameLn |
|
| PrefixedName.PnameNs |
|
| PrefixedName.Visitor<R> |
|
| PreIncrementExpression |
|
| PrettyPrinter |
A temporary pretty-printer for terms, for the sake of tests and debugging.
|
| Primary |
|
| Primary |
|
| Primary.ArrayCreation |
|
| Primary.Compound |
|
| Primary.NoNewArray |
|
| Primary.PartialVisitor<R> |
|
| Primary.PartialVisitor<R> |
|
| Primary.Simple |
|
| Primary.Visitor<R> |
|
| Primary.Visitor<R> |
|
| PrimaryKey |
A primary key of a relation, specified either as a single column, or as a list of columns
|
| PrimaryNoNewArrayExpression |
|
| PrimaryNoNewArrayExpression.ArrayAccess |
|
| PrimaryNoNewArrayExpression.ClassInstance |
|
| PrimaryNoNewArrayExpression.ClassLiteral |
|
| PrimaryNoNewArrayExpression.DotThis |
|
| PrimaryNoNewArrayExpression.FieldAccess |
|
| PrimaryNoNewArrayExpression.Literal |
|
| PrimaryNoNewArrayExpression.MethodInvocation |
|
| PrimaryNoNewArrayExpression.MethodReference |
|
| PrimaryNoNewArrayExpression.Parens |
|
| PrimaryNoNewArrayExpression.PartialVisitor<R> |
|
| PrimaryNoNewArrayExpression.This |
|
| PrimaryNoNewArrayExpression.Visitor<R> |
|
| PrimaryRhs |
|
| PrimaryRhs.Call |
|
| PrimaryRhs.Genexp |
|
| PrimaryRhs.PartialVisitor<R> |
|
| PrimaryRhs.Project |
|
| PrimaryRhs.Slices |
|
| PrimaryRhs.Visitor<R> |
|
| PrimaryWithRhs |
|
| Primitive |
A built-in function or constant
|
| PrimitiveFunction |
Any of Hydra's primitive functions, implemented in Java.
|
| PrimitiveType |
|
| PrimitiveType<T> |
A wrapper for a type which can be used as the basis of equality and comparison primitives.
|
| PrimitiveType.Boolean_ |
|
| PrimitiveType.Numeric |
|
| PrimitiveType.PartialVisitor<R> |
|
| PrimitiveType.TriFunction<A,B,C,R> |
A function of three arguments.
|
| PrimitiveType.Visitor<R> |
|
| PrimitiveTypedValue |
|
| PrimitiveTypeWithAnnotations |
|
| Printing |
Printing functions for property graph elements
|
| ProcedureCallFeatures |
Procedure calls
|
| ProcedureInvocation |
|
| ProcedureInvocation.Explicit |
|
| ProcedureInvocation.Implicit |
|
| ProcedureInvocation.PartialVisitor<R> |
|
| ProcedureInvocation.Visitor<R> |
|
| ProcedureResultField |
|
| Program |
A Lisp program, consisting of a sequence of top-level forms
|
| Projection |
A record elimination; a projection
|
| Projection |
|
| ProjectionBody |
|
| ProjectionFeatures |
Projections
|
| ProjectionItem |
|
| ProjectionItems |
|
| Projections |
|
| Properties |
|
| Properties.Map |
|
| Properties.Parameter |
|
| Properties.PartialVisitor<R> |
|
| Properties.Visitor<R> |
|
| Property |
A type representing an RDF property, and encapsulating its domain, range, and subclass relationships
|
| Property<V> |
A key/value property
|
| PropertyArgs |
|
| PropertyArgs.CardinalityObject |
|
| PropertyArgs.CardinalityObjects |
|
| PropertyArgs.Object_ |
|
| PropertyArgs.Objects |
|
| PropertyArgs.PartialVisitor<R> |
|
| PropertyArgs.Visitor<R> |
|
| PropertyEquals |
|
| PropertyExpression |
|
| PropertyFeatures |
A base interface for Edge or Vertex Property features.
|
| PropertyKey |
|
| PropertyKey |
A property key
|
| PropertyKeyName |
|
| PropertyLookup |
|
| PropertyPattern |
|
| PropertyProjection |
|
| PropertyShape |
A SHACL property shape.
|
| PropertyShapeConstraint |
A number of constraint parameters which are specific to property shapes, and cannot be applied to node shapes
|
| PropertyShapeConstraint.LessThan |
See https://www.w3.org/TR/shacl/#LessThanConstraintComponent
|
| PropertyShapeConstraint.LessThanOrEquals |
See https://www.w3.org/TR/shacl/#LessThanOrEqualsConstraintComponent
|
| PropertyShapeConstraint.MaxCount |
The maximum cardinality.
|
| PropertyShapeConstraint.MinCount |
The minimum cardinality.
|
| PropertyShapeConstraint.PartialVisitor<R> |
|
| PropertyShapeConstraint.QualifiedValueShape |
See https://www.w3.org/TR/shacl/#QualifiedValueShapeConstraintComponent
|
| PropertyShapeConstraint.UniqueLang |
See https://www.w3.org/TR/shacl/#UniqueLangConstraintComponent
|
| PropertyShapeConstraint.Visitor<R> |
|
| PropertySpec |
A mapping specification producing properties of a specified key, and values of the appropriate type.
|
| PropertyType<T> |
The type of a property
|
| PropertyValue |
|
| PropertyValuePattern |
|
| PropertyValuePattern.PartialVisitor<R> |
|
| PropertyValuePattern.Value |
|
| PropertyValuePattern.Variable |
|
| PropertyValuePattern.Visitor<R> |
|
| Pure |
Wraps a value in a flow.
|
| Pure |
Wraps a value in a flow.
|
| PyGraph |
Combined graph and metadata state for Python code generation
|
| PythonEnvironment |
Environment for Python code generation
|
| PythonModuleMetadata |
Temporary metadata used to create the header section of a Python file
|
| PythonVersion |
Target Python version for code generation
|
| PythonVersion.PartialVisitor<R> |
|
| PythonVersion.Python310 |
|
| PythonVersion.Python312 |
|
| PythonVersion.Visitor<R> |
|
| QName |
|
| Quad |
An RDF triple with an optional named graph component
|
| QualifiedName |
|
| QualifiedName |
A qualified name
|
| QualifiedName |
A qualified name consisting of an optional namespace together with a mandatory local name
|
| QualifiedSymbol |
A namespace-qualified symbol.
|
| QualifiedValueShape |
See https://www.w3.org/TR/shacl/#QualifiedValueShapeConstraintComponent
|
| Quantifier |
|
| QuantifierFeatures |
Quantifier expressions
|
| QuantifierOperator |
|
| QuantifierOperator.All |
|
| QuantifierOperator.Any |
|
| QuantifierOperator.None |
|
| QuantifierOperator.PartialVisitor<R> |
|
| QuantifierOperator.Single |
|
| QuantifierOperator.Visitor<R> |
|
| Quasi |
|
| QuasiquoteExpression |
A quasiquoted form: `expr
|
| Queries |
DSL for constructing property graph queries.
|
| Query |
Term decoders for hydra.query
|
| Query |
DSL functions for hydra.query
|
| Query |
Term encoders for hydra.query
|
| Query |
|
| Query |
|
| Query |
|
| Query |
A SELECT-style graph pattern matching query
|
| Query.Aggregate |
|
| Query.Application |
|
| Query.Empty |
|
| Query.LetQuery |
|
| Query.Match |
|
| Query.PartialVisitor<R> |
|
| Query.PartialVisitor<R> |
|
| Query.PartialVisitor<R> |
|
| Query.Regular |
|
| Query.RootTraversal |
|
| Query.Select |
|
| Query.Standalone |
|
| Query.ToString |
|
| Query.TraversalSource |
|
| Query.Value |
|
| Query.Visitor<R> |
|
| Query.Visitor<R> |
|
| Query.Visitor<R> |
|
| QueryList |
|
| QuoteExpression |
A quoted form: 'expr or (quote expr)
|
| QuoteStyle |
|
| QuoteStyle.Double_ |
|
| QuoteStyle.PartialVisitor<R> |
|
| QuoteStyle.Single |
|
| QuoteStyle.Triple |
|
| QuoteStyle.Visitor<R> |
|
| RaiseExpression |
|
| RaiseStatement |
|
| Range |
Generates a range of integers.
|
| Range |
A range from min to max, inclusive
|
| RangeArgs |
|
| RangeArgument |
|
| RangeExpression |
|
| RangeLiteral |
|
| RangeLiteralFeatures |
Range literals within relationship patterns
|
| RdfLiteral |
|
| RdfLiteral_Alts_Option |
|
| RdfLiteral_Alts_Option.LangTag |
|
| RdfLiteral_Alts_Option.PartialVisitor<R> |
|
| RdfLiteral_Alts_Option.Sequence |
|
| RdfLiteral_Alts_Option.Visitor<R> |
|
| RdfsClass |
Stand-in for rdfs:Class
|
| RdfType |
|
| ReadBigfloat |
Primitive function which parses a string into a bigfloat (arbitrary-precision decimal).
|
| ReadBigint |
Primitive function which parses a string into a bigint (arbitrary precision integer).
|
| ReadBoolean |
Primitive function which parses a string into a boolean.
|
| ReadFloat32 |
Primitive function which parses a string into a float32 (32-bit floating-point).
|
| ReadFloat64 |
Primitive function which parses a string into a float64 (64-bit floating-point).
|
| ReadingClause |
|
| ReadingClause.InQueryCall |
|
| ReadingClause.Match |
|
| ReadingClause.PartialVisitor<R> |
|
| ReadingClause.Unwind |
|
| ReadingClause.Visitor<R> |
|
| ReadingFeatures |
Specific syntax related to reading data from the graph.
|
| ReadInt16 |
Primitive function which parses a string into an int16 (16-bit signed integer).
|
| ReadInt32 |
Primitive function which parses a string into an int32 (32-bit signed integer).
|
| ReadInt64 |
Primitive function which parses a string into an int64 (64-bit signed integer).
|
| ReadInt8 |
Primitive function which parses a string into an int8 (8-bit signed integer).
|
| ReadString |
Primitive function which parses a string literal representation into a string value.
|
| ReadUint16 |
Primitive function which parses a string into a uint16 (16-bit unsigned integer).
|
| ReadUint32 |
Primitive function which parses a string into a uint32 (32-bit unsigned integer).
|
| ReadUint64 |
Primitive function which parses a string into a uint64 (64-bit unsigned integer).
|
| ReadUint8 |
Primitive function which parses a string into a uint8 (8-bit unsigned integer).
|
| RealNumber |
|
| ReceiverParameter |
|
| Record |
A record, or labeled tuple; a map of field names to terms
|
| RecordConstructor |
A record-style data constructor
|
| RecordPattern |
A record pattern
|
| RecordTypeDefinition |
A record/struct type definition.
|
| Reduction |
Functions for reducing terms and types, i.e.
|
| RedundantWrapUnwrapError |
An unwrap elimination applied to a wrap term of the same type, forming a no-op round-trip (optional)
|
| Ref |
|
| Ref.Init |
|
| Ref.Name |
|
| Ref.PartialVisitor<R> |
|
| Ref.Visitor<R> |
|
| Reference<A> |
Either an instance of a type like sh:Shape or sh:NodeShape, or an IRI which refers to an instance of that type
|
| Reference.Anonymous<A> |
An anonymous instance
|
| Reference.Definition<A> |
An inline definition
|
| Reference.Named<A> |
|
| Reference.PartialVisitor<A,R> |
|
| Reference.Visitor<A,R> |
|
| ReferenceType |
|
| ReferenceType.Array |
|
| ReferenceType.ClassOrInterface |
|
| ReferenceType.PartialVisitor<R> |
|
| ReferenceType.Variable |
|
| ReferenceType.Visitor<R> |
|
| Reflect |
Reflection functions for working with term, type, and literal type variants, as well as numeric precision.
|
| ReflexiveObjectProperty |
|
| Regexp |
|
| Regexp_ListOfAlts_Elmt |
|
| Regexp_ListOfAlts_Elmt.PartialVisitor<R> |
|
| Regexp_ListOfAlts_Elmt.Regex |
|
| Regexp_ListOfAlts_Elmt.Sequence |
|
| Regexp_ListOfAlts_Elmt.Uchar |
|
| Regexp_ListOfAlts_Elmt.Visitor<R> |
|
| RegexQuantifier |
A regular expression quantifier
|
| RegexQuantifier.AtLeast |
The {n,} quantifier; matches at least n occurrences
|
| RegexQuantifier.Exactly |
The {n} quantifier; matches exactly n occurrences
|
| RegexQuantifier.One |
No quantifier; matches a single occurrence
|
| RegexQuantifier.OneOrMore |
The + quantifier; matches one or more occurrences
|
| RegexQuantifier.PartialVisitor<R> |
|
| RegexQuantifier.Range |
The {n, m} quantifier; matches between n and m (inclusive) occurrences
|
| RegexQuantifier.Visitor<R> |
|
| RegexQuantifier.ZeroOrMore |
The * quantifier; matches any number of occurrences
|
| RegexQuantifier.ZeroOrOne |
The ? quanifier; matches zero or one occurrence
|
| RegexSequence |
A path with a regex quantifier
|
| RegularQuery |
|
| Relation<V> |
A set of distinct n-tuples; a table
|
| Relational |
Term decoders for hydra.relational
|
| Relational |
DSL functions for hydra.relational
|
| Relational |
Term encoders for hydra.relational
|
| RelationalExpression |
|
| RelationalExpression_GreaterThan |
|
| RelationalExpression_GreaterThanEqual |
|
| RelationalExpression_InstanceOf |
|
| RelationalExpression_LessThan |
|
| RelationalExpression_LessThanEqual |
|
| RelationalExpression.GreaterThan |
|
| RelationalExpression.GreaterThanEqual |
|
| RelationalExpression.Instanceof |
|
| RelationalExpression.LessThan |
|
| RelationalExpression.LessThanEqual |
|
| RelationalExpression.PartialVisitor<R> |
|
| RelationalExpression.Simple |
|
| RelationalExpression.Visitor<R> |
|
| RelationName |
A unique relation (table) name
|
| RelationSchema<T> |
An abstract relation; the name and columns of a relation without its actual data
|
| Relationship<V> |
A domain-unordered (string-indexed, rather than position-indexed) relation
|
| RelationshipDetail |
|
| RelationshipDirectionFeatures |
Relationship directions / arrow patterns
|
| RelationshipPattern |
|
| RelationshipPatternFeatures |
Relationship patterns
|
| RelationshipsPattern |
|
| RelationshipTypes |
|
| RelativeImportPrefix |
|
| RelativeImportPrefix.Dot |
|
| RelativeImportPrefix.Ellipsis |
|
| RelativeImportPrefix.PartialVisitor<R> |
|
| RelativeImportPrefix.Visitor<R> |
|
| RelTypeName |
|
| Rem |
Computes the remainder of integer division.
|
| Remove |
|
| RemoveFeatures |
REMOVE operations
|
| RemoveItem |
|
| RemoveItem.PartialVisitor<R> |
|
| RemoveItem.Property |
|
| RemoveItem.VariableLabels |
|
| RemoveItem.Visitor<R> |
|
| RepeatRange |
|
| RepeatRange_Sequence_Option_Option_Option |
|
| RepeatRange_Sequence_Option_Option_Option.Ast |
|
| RepeatRange_Sequence_Option_Option_Option.Integer_ |
|
| RepeatRange_Sequence_Option_Option_Option.PartialVisitor<R> |
|
| RepeatRange_Sequence_Option_Option_Option.Visitor<R> |
|
| Replace |
Replaces the first occurrence of a regex pattern with a replacement string.
|
| ReplaceAll |
Replaces all non-overlapping occurrences of a regex pattern with a replacement string.
|
| ReplaceArgs |
|
| Replicate |
Creates a list of n copies.
|
| RequiresModifier |
|
| RequiresModifier.PartialVisitor<R> |
|
| RequiresModifier.Static |
|
| RequiresModifier.Transitive |
|
| RequiresModifier.Visitor<R> |
|
| Resource |
|
| Resource |
|
| Resource_Local |
|
| Resource.Bnode |
|
| Resource.Iri |
|
| Resource.Local |
|
| Resource.PartialVisitor<R> |
|
| Resource.PartialVisitor<R> |
|
| Resource.Variable |
|
| Resource.Visitor<R> |
|
| Resource.Visitor<R> |
|
| ResourceSpecification |
|
| Result |
|
| Result.PartialVisitor<R> |
|
| Result.Type |
|
| Result.Visitor<R> |
|
| Result.Void_ |
|
| Return |
|
| ReturnStatement |
|
| ReturnStatement |
|
| Reverse |
Reverses a list.
|
| RewriteTermTestCase |
A test case which applies a term rewriter and compares the result
|
| RewriteTypeTestCase |
A test case which applies a type rewriter and compares the result
|
| Rewriting |
Utilities for type and term rewriting and analysis.
|
| RightHandSide |
A right-hand side of a binding
|
| Rights |
Extract all Right values from a list of Eithers.
|
| RootTraversal |
|
| RootTraversalQuery |
|
| Round |
Rounds to the nearest integer.
|
| RoundBigfloat |
Rounds a bigfloat to n significant digits.
|
| RoundFloat32 |
Rounds a float32 to n significant digits.
|
| RoundFloat64 |
Rounds a float64 to n significant digits.
|
| Row<V> |
An n-tuple which is an element of a given relation
|
| SafeHead |
Safely returns the first element.
|
| SameIndividual |
|
| Scalar |
A union of scalars supported in the YAML failsafe and JSON schemas.
|
| Scalar.Bool |
Represents a true/false value
|
| Scalar.Float_ |
Represents an approximation to real numbers
|
| Scalar.Int |
Represents arbitrary sized finite mathematical integers
|
| Scalar.Null |
Represents the lack of a value
|
| Scalar.PartialVisitor<R> |
|
| Scalar.Str |
A string value
|
| Scalar.Visitor<R> |
|
| ScalarFunctionFeatures |
Scalar functions
|
| ScalaSymbol |
|
| Schema<S,T,V> |
A set of mappings which translates between Hydra terms and annotations, and application-specific property graph types
|
| Schemas |
Various functions for dereferencing and decoding schema types.
|
| ScopeStringArgument |
|
| Second |
Extracts the second element of a pair.
|
| SectionExpression |
A section expression
|
| SelectArgs |
|
| SelectArgs.Column |
|
| SelectArgs.PartialVisitor<R> |
|
| SelectArgs.PopStrings |
|
| SelectArgs.PopTraversal |
|
| SelectArgs.Strings |
|
| SelectArgs.Traversal |
|
| SelectArgs.Visitor<R> |
|
| SelectQuery |
|
| Self |
|
| SelfApplicationError |
A variable applied to itself, which is almost always a mistake in Hydra's type system (optional)
|
| SemanticActions |
|
| SenseFlags |
|
| SeqExpr |
A sequence of expressions joined by a separator operator.
|
| SequencePattern |
|
| SequencePattern.List |
|
| SequencePattern.PartialVisitor<R> |
|
| SequencePattern.Tuple |
|
| SequencePattern.Visitor<R> |
|
| Serde |
Haskell operator precendence and associativity are drawn from:
https://self-learning-java-tutorial.blogspot.com/2016/04/haskell-operator-precedence.html
Other operators were investigated using GHCi, e.g.
|
| Serde |
Java serializer: converts Java AST to concrete syntax
|
| Serde |
Lisp serializer: converts Lisp AST to concrete syntax for Clojure, Emacs Lisp, Common Lisp, or Scheme
|
| Serde |
Python serializer: converts Python AST to concrete syntax
|
| Serde |
Serialization functions for converting RDF graphs to N-Triples format expressions
|
| Serde |
Serialization functions for converting Scala AST to abstract expressions
|
| Serialization |
Utilities for constructing generic program code ASTs, used for the serialization phase of source code generation.
|
| SerializationTestCase |
A test case which serializes an AST expression to a string and compares it with the expected output
|
| ServiceArguments |
|
| ServiceArguments.Map |
|
| ServiceArguments.PartialVisitor<R> |
|
| ServiceArguments.Traversal |
|
| ServiceArguments.Visitor<R> |
|
| ServiceCall |
|
| Set |
|
| Set |
|
| Setcomp |
|
| SetFeatures |
Set definitions
|
| SetItem |
|
| SetItem.PartialVisitor<R> |
|
| SetItem.Property |
|
| SetItem.VariableEqual |
|
| SetItem.VariableLabels |
|
| SetItem.VariablePlusEqual |
|
| SetItem.Visitor<R> |
|
| SetLiteral |
A set literal.
|
| Sets |
DSL interface providing set primitive operations.
|
| Sets |
Evaluation-level implementations of Set functions for the Hydra interpreter.
|
| Severity |
|
| Severity.Info |
A non-critical constraint violation indicating an informative message
|
| Severity.PartialVisitor<R> |
|
| Severity.Violation |
A constraint violation
|
| Severity.Visitor<R> |
|
| Severity.Warning |
A non-critical constraint violation indicating a warning
|
| SExpression |
A raw S-expression.
|
| SExpression.Atom |
An atomic value
|
| SExpression.List |
A list of S-expressions
|
| SExpression.PartialVisitor<R> |
|
| SExpression.Visitor<R> |
|
| Shape |
A SHACL node or property shape.
|
| Shape.Node |
|
| Shape.PartialVisitor<R> |
|
| Shape.Property |
|
| Shape.Visitor<R> |
|
| ShapeAnd |
|
| ShapeAtom |
|
| ShapeAtom_Sequence |
|
| ShapeAtom.PartialVisitor<R> |
|
| ShapeAtom.Period |
|
| ShapeAtom.Sequence |
|
| ShapeAtom.Sequence2 |
|
| ShapeAtom.ShapeOrRef |
|
| ShapeAtom.Visitor<R> |
|
| ShapeDefinition |
|
| ShapeDefinition_ListOfAlts_Elmt |
|
| ShapeDefinition_ListOfAlts_Elmt.CLOSED |
|
| ShapeDefinition_ListOfAlts_Elmt.ExtraPropertySet |
|
| ShapeDefinition_ListOfAlts_Elmt.IncludeSet |
|
| ShapeDefinition_ListOfAlts_Elmt.PartialVisitor<R> |
|
| ShapeDefinition_ListOfAlts_Elmt.Visitor<R> |
|
| ShapeExpression |
|
| ShapeExprLabel |
|
| ShapeExprLabel.BlankNode |
|
| ShapeExprLabel.Iri |
|
| ShapeExprLabel.PartialVisitor<R> |
|
| ShapeExprLabel.Visitor<R> |
|
| ShapeNot |
|
| ShapeOr |
|
| ShapeOrRef |
|
| ShapeOrRef.AtpNameLn |
|
| ShapeOrRef.AtpNameNs |
|
| ShapeOrRef.PartialVisitor<R> |
|
| ShapeOrRef.Sequence |
|
| ShapeOrRef.ShapeDefinition |
|
| ShapeOrRef.Visitor<R> |
|
| ShapesGraph |
An RDF graph containing zero or more shapes that is passed into a SHACL validation process so that a data graph can be validated against the shapes
|
| ShexDoc |
|
| ShexDoc_Sequence_Option |
|
| ShexDoc_Sequence_Option_Alts |
|
| ShexDoc_Sequence_Option_Alts.NotStartAction |
|
| ShexDoc_Sequence_Option_Alts.PartialVisitor<R> |
|
| ShexDoc_Sequence_Option_Alts.StartActions |
|
| ShexDoc_Sequence_Option_Alts.Visitor<R> |
|
| ShiftExpression |
|
| ShiftExpression |
|
| ShiftExpression_Binary |
|
| ShiftExpression.PartialVisitor<R> |
|
| ShiftExpression.ShiftLeft |
|
| ShiftExpression.ShiftRight |
|
| ShiftExpression.ShiftRightZeroFill |
|
| ShiftExpression.Unary |
|
| ShiftExpression.Visitor<R> |
|
| ShiftLhs |
|
| ShiftOp |
|
| ShiftOp.Left |
|
| ShiftOp.PartialVisitor<R> |
|
| ShiftOp.Right |
|
| ShiftOp.Visitor<R> |
|
| Short_ |
|
| ShortestPathConstants |
|
| ShortestPathConstants.Distance |
|
| ShortestPathConstants.Edges |
|
| ShortestPathConstants.IncludeEdges |
|
| ShortestPathConstants.MaxDistance |
|
| ShortestPathConstants.PartialVisitor<R> |
|
| ShortestPathConstants.Target |
|
| ShortestPathConstants.Visitor<R> |
|
| ShowBigfloat |
Primitive function which converts a bigfloat (arbitrary-precision decimal) to its string representation.
|
| ShowBigint |
Primitive function which converts a bigint (arbitrary-precision integer) to its string representation.
|
| ShowBoolean |
Primitive function which converts a boolean to its string representation.
|
| ShowFloat32 |
Primitive function which converts a float32 (32-bit floating-point) to its string representation.
|
| ShowFloat64 |
Primitive function which converts a float64 (64-bit floating-point) to its string representation.
|
| ShowInt16 |
Primitive function which converts an int16 (16-bit signed integer) to its string representation.
|
| ShowInt32 |
Primitive function which converts an int32 (32-bit signed integer) to its string representation.
|
| ShowInt64 |
Primitive function which converts an int64 (64-bit signed integer) to its string representation.
|
| ShowInt8 |
Primitive function which converts an int8 (8-bit signed integer) to its string representation.
|
| ShowString |
Primitive function which converts a string to its quoted string literal representation.
|
| ShowTerm |
Converts a term to its string representation.
|
| ShowUint16 |
Primitive function which converts a uint16 (16-bit unsigned integer) to its string representation.
|
| ShowUint32 |
Primitive function which converts a uint32 (32-bit unsigned integer) to its string representation.
|
| ShowUint64 |
Primitive function which converts a uint64 (64-bit unsigned integer) to its string representation.
|
| ShowUint8 |
Primitive function which converts a uint8 (8-bit unsigned integer) to its string representation.
|
| SignedNumber |
|
| SignedNumber.Number_ |
|
| SignedNumber.PartialVisitor<R> |
|
| SignedNumber.Sign |
|
| SignedNumber.Visitor<R> |
|
| SignedRealNumber |
|
| SignedRealNumber.Number_ |
|
| SignedRealNumber.PartialVisitor<R> |
|
| SignedRealNumber.Sign |
|
| SignedRealNumber.Visitor<R> |
|
| Signum |
Returns the sign of a number.
|
| SimpleBinding |
A simple name-value binding in a let expression
|
| SimpleStatement |
|
| SimpleStatement.Assert |
|
| SimpleStatement.Assignment |
|
| SimpleStatement.Break |
|
| SimpleStatement.Continue |
|
| SimpleStatement.Del |
|
| SimpleStatement.Global |
|
| SimpleStatement.Import |
|
| SimpleStatement.Nonlocal |
|
| SimpleStatement.PartialVisitor<R> |
|
| SimpleStatement.Pass |
|
| SimpleStatement.Raise |
|
| SimpleStatement.Return |
|
| SimpleStatement.StarExpressions |
|
| SimpleStatement.TypeAlias |
|
| SimpleStatement.Visitor<R> |
|
| SimpleStatement.Yield |
|
| SimpleTypeName |
|
| SimpleTypeParameter |
|
| SimpleValueBinding |
A simple value binding
|
| SimplifyTermTestCase |
A test case which performs term simplification (beta reduction and optimization) and compares the result with the expected term
|
| Sin |
Computes the sine of an angle.
|
| SingleElementAnnotation |
|
| SingleElementGroup |
|
| SinglePartQuery |
|
| SingleQuery |
|
| SingleQuery.MultiPart |
|
| SingleQuery.PartialVisitor<R> |
|
| SingleQuery.SinglePart |
|
| SingleQuery.Visitor<R> |
|
| SingleStaticImportDeclaration |
|
| SingleSubscriptAttributeTarget |
|
| SingleSubscriptAttributeTarget.PartialVisitor<R> |
|
| SingleSubscriptAttributeTarget.PrimaryAndName |
|
| SingleSubscriptAttributeTarget.PrimaryAndSlices |
|
| SingleSubscriptAttributeTarget.Visitor<R> |
|
| SingleTarget |
|
| SingleTarget.Name |
|
| SingleTarget.Parens |
|
| SingleTarget.PartialVisitor<R> |
|
| SingleTarget.SubscriptAttributeTarget |
|
| SingleTarget.Visitor<R> |
|
| Singleton |
Creates a singleton list.
|
| Singleton |
Creates a singleton list.
|
| Singleton |
Creates a singleton set containing a single element.
|
| SingleTypeImportDeclaration |
|
| SingleVariantUnionError |
A union type with exactly one field; could be a wrapped type or record instead (optional)
|
| Sinh |
Computes the hyperbolic sine.
|
| Size |
Returns the number of entries.
|
| Size |
Returns the number of elements in a set.
|
| Skip |
|
| SlashNoDefault |
|
| SlashNoDefaultParameters |
|
| SlashWithDefault |
|
| SlashWithDefaultParameters |
|
| Slice |
|
| Slice.Named |
|
| Slice.PartialVisitor<R> |
|
| Slice.Slice_ |
|
| Slice.Visitor<R> |
|
| SliceExpression |
|
| SliceOrStarredExpression |
|
| SliceOrStarredExpression.PartialVisitor<R> |
|
| SliceOrStarredExpression.Slice |
|
| SliceOrStarredExpression.Starred |
|
| SliceOrStarredExpression.Visitor<R> |
|
| Slices |
|
| Sort |
Sorts a list.
|
| Sorting |
Utilities for sorting.
|
| SortItem |
|
| SortOn |
Sorts a list by a key function.
|
| SortOrder |
|
| SortOrder.Ascending |
|
| SortOrder.Descending |
|
| SortOrder.PartialVisitor<R> |
|
| SortOrder.Visitor<R> |
|
| Source |
|
| Span |
Splits a list at the first element not matching a predicate.
|
| SpatialFunctionFeatures |
Spatial functions
|
| SpecImport |
An import specification
|
| SpecImport.Hiding |
A list of imports to exclude
|
| SpecImport.List |
A list of imports to include
|
| SpecImport.PartialVisitor<R> |
|
| SpecImport.Visitor<R> |
|
| SplicingUnquoteExpression |
A splicing unquote within a quasiquote: ~@expr or ,@expr
|
| Split |
Splits a string by a regex pattern.
|
| SplitArgs |
|
| SplitOn |
Splits a string on a given delimiter.
|
| Sqrt |
Computes the square root.
|
| StandaloneCall |
|
| StarAnnotation |
|
| StarAtom |
|
| StarAtom.Name |
|
| StarAtom.PartialVisitor<R> |
|
| StarAtom.StarTargetsListSeq |
|
| StarAtom.StarTargetsTupleSeq |
|
| StarAtom.TargetWithStarAtom |
|
| StarAtom.Visitor<R> |
|
| StarEtc |
|
| StarEtc.Keywords |
|
| StarEtc.PartialVisitor<R> |
|
| StarEtc.StarComma |
|
| StarEtc.StarNoDefault |
|
| StarEtc.StarNoDefaultStarAnnotation |
|
| StarEtc.Visitor<R> |
|
| StarExpression |
|
| StarExpression.PartialVisitor<R> |
|
| StarExpression.Simple |
|
| StarExpression.Star |
|
| StarExpression.Visitor<R> |
|
| StarNamedExpression |
|
| StarNamedExpression.PartialVisitor<R> |
|
| StarNamedExpression.Simple |
|
| StarNamedExpression.Star |
|
| StarNamedExpression.Visitor<R> |
|
| StarNamedExpressions |
|
| StarOrYieldItems |
|
| StarOrYieldItems.Items |
|
| StarOrYieldItems.PartialVisitor<R> |
|
| StarOrYieldItems.Star |
|
| StarOrYieldItems.Visitor<R> |
|
| StarPattern |
|
| StarPattern.Capture |
|
| StarPattern.PartialVisitor<R> |
|
| StarPattern.Visitor<R> |
|
| StarPattern.Wildcard |
|
| StarredExpression |
|
| StartActions |
|
| StarTarget |
|
| StarTarget.PartialVisitor<R> |
|
| StarTarget.Starred |
|
| StarTarget.Unstarred |
|
| StarTarget.Visitor<R> |
|
| StarTargetsListSeq |
|
| StarTargetsTupleSeq |
|
| StarTypeParameter |
|
| Stat |
|
| Stat.Decl |
|
| Stat.Defn |
|
| Stat.ImportExport |
|
| Stat.PartialVisitor<R> |
|
| Stat.Term |
|
| Stat.Visitor<R> |
|
| StatelessAdapter<T1,T2,V1,V2> |
A convenience class for stateless adapters.
|
| StatelessCoder<V1,V2> |
A convenience class for stateless coders that wraps simple encode/decode functions.
|
| Statement |
A do-notation statement
|
| Statement |
|
| Statement |
|
| Statement |
|
| Statement.Annotated |
|
| Statement.Compound |
|
| Statement.Directive |
|
| Statement.For |
|
| Statement.IfThen |
|
| Statement.IfThenElse |
|
| Statement.Labeled |
|
| Statement.NotStartAction |
|
| Statement.PartialVisitor<R> |
|
| Statement.PartialVisitor<R> |
|
| Statement.PartialVisitor<R> |
|
| Statement.Simple |
|
| Statement.Visitor<R> |
|
| Statement.Visitor<R> |
|
| Statement.Visitor<R> |
|
| Statement.While |
|
| Statement.WithoutTrailing |
|
| StatementExpression |
|
| StatementExpression.Assignment |
|
| StatementExpression.ClassInstanceCreation |
|
| StatementExpression.MethodInvocation |
|
| StatementExpression.PartialVisitor<R> |
|
| StatementExpression.PostDecrement |
|
| StatementExpression.PostIncrement |
|
| StatementExpression.PreDecrement |
|
| StatementExpression.PreIncrement |
|
| StatementExpression.Visitor<R> |
|
| StatementNoShortIf |
|
| StatementNoShortIf.For |
|
| StatementNoShortIf.IfThenElse |
|
| StatementNoShortIf.Labeled |
|
| StatementNoShortIf.PartialVisitor<R> |
|
| StatementNoShortIf.Visitor<R> |
|
| StatementNoShortIf.While |
|
| StatementNoShortIf.WithoutTrailing |
|
| StatementWithoutTrailingSubstatement |
|
| StatementWithoutTrailingSubstatement.Assert |
|
| StatementWithoutTrailingSubstatement.Block |
|
| StatementWithoutTrailingSubstatement.Break |
|
| StatementWithoutTrailingSubstatement.Continue |
|
| StatementWithoutTrailingSubstatement.Do |
|
| StatementWithoutTrailingSubstatement.Empty |
|
| StatementWithoutTrailingSubstatement.Expression |
|
| StatementWithoutTrailingSubstatement.PartialVisitor<R> |
|
| StatementWithoutTrailingSubstatement.Return |
|
| StatementWithoutTrailingSubstatement.Switch |
|
| StatementWithoutTrailingSubstatement.Synchronized |
|
| StatementWithoutTrailingSubstatement.Throw |
|
| StatementWithoutTrailingSubstatement.Try |
|
| StatementWithoutTrailingSubstatement.Visitor<R> |
|
| StaticImportOnDemandDeclaration |
|
| StaticInitializer |
|
| Step |
An atomic function as part of a query.
|
| Step.Compare |
A comparison of two terms
|
| Step.Edge |
An out-to-in traversal of an abstract edge
|
| Step.PartialVisitor<R> |
|
| Step.Project |
A projection from a record through one of its fields
|
| Step.Visitor<R> |
|
| String_ |
|
| String_ |
|
| String_ |
|
| String_.PartialVisitor<R> |
|
| String_.StringLiteral1 |
|
| String_.StringLiteral2 |
|
| String_.StringLiteralLong1 |
|
| String_.StringLiteralLong2 |
|
| String_.Visitor<R> |
|
| StringArgument |
|
| StringArgument.PartialVisitor<R> |
|
| StringArgument.Value |
|
| StringArgument.Variable |
|
| StringArgument.Visitor<R> |
|
| StringArgumentAndGenericLiteralArgument |
|
| StringArgumentAndOptionalGenericLiteralArgument |
|
| StringArgumentAndOptionalStringLiteralVarargs |
|
| StringArgumentOrNestedTraversal |
|
| StringArgumentOrNestedTraversal.PartialVisitor<R> |
|
| StringArgumentOrNestedTraversal.String_ |
|
| StringArgumentOrNestedTraversal.Traversal |
|
| StringArgumentOrNestedTraversal.Visitor<R> |
|
| StringFacet |
|
| StringFacet_Sequence |
|
| StringFacet.PartialVisitor<R> |
|
| StringFacet.Regexp |
|
| StringFacet.Sequence |
|
| StringFacet.Visitor<R> |
|
| StringFeatures |
String functions/keywords only found in OpenCypher
|
| StringFunctionFeatures |
String functions
|
| StringLength |
|
| StringLength.LENGTH |
|
| StringLength.MAXLENGTH |
|
| StringLength.MINLENGTH |
|
| StringLength.PartialVisitor<R> |
|
| StringLength.Visitor<R> |
|
| StringListNullPredicateExpression |
|
| StringListNullPredicateRightHandSide |
|
| StringListNullPredicateRightHandSide.List |
|
| StringListNullPredicateRightHandSide.Null |
|
| StringListNullPredicateRightHandSide.PartialVisitor<R> |
|
| StringListNullPredicateRightHandSide.String_ |
|
| StringListNullPredicateRightHandSide.Visitor<R> |
|
| StringLiteral |
|
| StringLiteral |
Note: this is an approximation which ignores encoding
|
| StringLiteral1 |
|
| StringLiteral1_Elmt |
|
| StringLiteral1_Elmt.Echar |
|
| StringLiteral1_Elmt.PartialVisitor<R> |
|
| StringLiteral1_Elmt.Regex |
|
| StringLiteral1_Elmt.Uchar |
|
| StringLiteral1_Elmt.Visitor<R> |
|
| StringLiteral2 |
|
| StringLiteral2_Elmt |
|
| StringLiteral2_Elmt.Echar |
|
| StringLiteral2_Elmt.PartialVisitor<R> |
|
| StringLiteral2_Elmt.Regex |
|
| StringLiteral2_Elmt.Uchar |
|
| StringLiteral2_Elmt.Visitor<R> |
|
| StringLiteralLong1 |
|
| StringLiteralLong1_Elmt |
|
| StringLiteralLong1_Elmt_Sequence |
|
| StringLiteralLong1_Elmt_Sequence_Alts_Option |
|
| StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence |
|
| StringLiteralLong1_Elmt_Sequence_Alts_Option.Apos |
|
| StringLiteralLong1_Elmt_Sequence_Alts_Option.PartialVisitor<R> |
|
| StringLiteralLong1_Elmt_Sequence_Alts_Option.Sequence |
|
| StringLiteralLong1_Elmt_Sequence_Alts_Option.Visitor<R> |
|
| StringLiteralLong1_Elmt.Echar |
|
| StringLiteralLong1_Elmt.PartialVisitor<R> |
|
| StringLiteralLong1_Elmt.Sequence |
|
| StringLiteralLong1_Elmt.Uchar |
|
| StringLiteralLong1_Elmt.Visitor<R> |
|
| StringLiteralLong2 |
|
| StringLiteralLong2_Elmt |
|
| StringLiteralLong2_Elmt_Sequence |
|
| StringLiteralLong2_Elmt_Sequence_Alts_Option |
|
| StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence |
|
| StringLiteralLong2_Elmt_Sequence_Alts_Option.PartialVisitor<R> |
|
| StringLiteralLong2_Elmt_Sequence_Alts_Option.Quot |
|
| StringLiteralLong2_Elmt_Sequence_Alts_Option.Sequence |
|
| StringLiteralLong2_Elmt_Sequence_Alts_Option.Visitor<R> |
|
| StringLiteralLong2_Elmt.Echar |
|
| StringLiteralLong2_Elmt.PartialVisitor<R> |
|
| StringLiteralLong2_Elmt.Sequence |
|
| StringLiteralLong2_Elmt.Uchar |
|
| StringLiteralLong2_Elmt.Visitor<R> |
|
| StringNullableArgument |
|
| StringNullableArgument.PartialVisitor<R> |
|
| StringNullableArgument.Value |
|
| StringNullableArgument.Variable |
|
| StringNullableArgument.Visitor<R> |
|
| StringNullableArgumentAndGenericLiteralArgument |
|
| StringNullableArgumentAndTraversalPredicate |
|
| StringPredicateExpression |
|
| StringPredicateOperator |
|
| StringPredicateOperator.Contains |
|
| StringPredicateOperator.EndsWith |
|
| StringPredicateOperator.PartialVisitor<R> |
|
| StringPredicateOperator.StartsWith |
|
| StringPredicateOperator.Visitor<R> |
|
| StringRange |
|
| Strings |
DSL interface providing string primitive operations.
|
| StringToBinary |
Primitive function which converts a string to binary data.
|
| StructureVertex |
|
| StructureVertexArgument |
|
| StructureVertexArgument.PartialVisitor<R> |
|
| StructureVertexArgument.Value |
|
| StructureVertexArgument.Variable |
|
| StructureVertexArgument.Visitor<R> |
|
| Sub |
Performs subtraction on two numbers.
|
| SubAnnotationPropertyOf |
|
| SubClassOf |
|
| SubDataPropertyOf |
|
| SubjectExpression |
|
| SubjectExpression.PartialVisitor<R> |
|
| SubjectExpression.Simple |
|
| SubjectExpression.Tuple |
|
| SubjectExpression.Visitor<R> |
|
| SubObjectPropertyOf |
|
| SubspecImportExportSpec |
A subspecification within an import/export
|
| SubspecImportExportSpec.All |
Import/export all
|
| SubspecImportExportSpec.List |
Import/export specific names
|
| SubspecImportExportSpec.PartialVisitor<R> |
|
| SubspecImportExportSpec.Visitor<R> |
|
| SubstInTypeTestCase |
A test case which applies a type substitution to a type and compares the result.
|
| Substitution |
Variable substitution in type and term expressions.
|
| SubstringArgs |
|
| SubtermEdge |
An edge in a subterm graph, connecting two nodes via a path
|
| SubtermGraph |
A graph of subterm nodes and edges, representing term access patterns
|
| SubtermNode |
A node in a subterm graph, representing a term or subterm
|
| SubtermPath |
A sequence of subterm steps forming a path through a term
|
| SubtermStep |
A function which maps from a term to a particular immediate subterm
|
| SubtermStep.AnnotatedBody |
Access the body of an annotated term
|
| SubtermStep.ApplicationArgument |
Access the argument of an application term
|
| SubtermStep.ApplicationFunction |
Access the function of an application term
|
| SubtermStep.InjectionTerm |
Access the term inside a union injection
|
| SubtermStep.LambdaBody |
Access the body of a lambda term
|
| SubtermStep.LetBinding |
Access a specific binding in a let term by variable name
|
| SubtermStep.LetBody |
Access the body of a let term
|
| SubtermStep.ListElement |
Access an element of a list by index
|
| SubtermStep.MapKey |
Access a key in a map by index
|
| SubtermStep.MapValue |
Access a value in a map by index
|
| SubtermStep.MaybeTerm |
Access the term inside a Just value
|
| SubtermStep.PartialVisitor<R> |
|
| SubtermStep.ProductTerm |
Access an element of a product (tuple) by index
|
| SubtermStep.RecordField |
Access a field of a record by field name
|
| SubtermStep.SetElement |
Access an element of a set by index
|
| SubtermStep.SumTerm |
Access the term inside a sum variant
|
| SubtermStep.TypeApplicationTerm |
Access the term being applied to a type
|
| SubtermStep.TypeLambdaBody |
Access the body of a type lambda term
|
| SubtermStep.UnionCasesBranch |
Access a specific branch of a union elimination by field name
|
| SubtermStep.UnionCasesDefault |
Access the default case of a union elimination
|
| SubtermStep.Visitor<R> |
|
| SubtermStep.WrappedTerm |
Access the term inside a wrapped term
|
| SubtypeEdge |
An edge in a subtype graph, connecting two nodes via a path
|
| SubtypeGraph |
A graph of subtype nodes and edges, representing type access patterns
|
| SubtypeNode |
A node in a subtype graph, representing a type or subtype
|
| SubtypePath |
A sequence of subtype steps forming a path through a type
|
| SubtypeStep |
A function which maps from a type to a particular immediate subtype
|
| SubtypeStep.AnnotatedBody |
Access the body of an annotated type
|
| SubtypeStep.ApplicationArgument |
Access the argument of an application type
|
| SubtypeStep.ApplicationFunction |
Access the function of an application type
|
| SubtypeStep.EitherLeft |
Access the left type of an either type
|
| SubtypeStep.EitherRight |
Access the right type of an either type
|
| SubtypeStep.ForallBody |
Access the body of a universally quantified type
|
| SubtypeStep.FunctionCodomain |
Access the codomain type of a function type
|
| SubtypeStep.FunctionDomain |
Access the domain type of a function type
|
| SubtypeStep.ListElement |
Access the element type of a list type
|
| SubtypeStep.MapKeys |
Access the key type of a map type
|
| SubtypeStep.MapValues |
Access the value type of a map type
|
| SubtypeStep.MaybeElement |
Access the element type of an optional type
|
| SubtypeStep.PairFirst |
Access the first type of a pair type
|
| SubtypeStep.PairSecond |
Access the second type of a pair type
|
| SubtypeStep.PartialVisitor<R> |
|
| SubtypeStep.RecordField |
Access a field type of a record type by field name
|
| SubtypeStep.SetElement |
Access the element type of a set type
|
| SubtypeStep.UnionField |
Access a field type of a union type by field name
|
| SubtypeStep.Visitor<R> |
|
| SubtypeStep.WrappedType |
Access the type inside a wrapped type
|
| Succ |
Returns the successor of an integer.
|
| Sum |
|
| SumLhs |
|
| SumOp |
|
| SumOp.Add |
|
| SumOp.PartialVisitor<R> |
|
| SumOp.Sub |
|
| SumOp.Visitor<R> |
|
| SwitchBlock |
|
| SwitchBlock_Pair |
|
| SwitchBlockStatementGroup |
|
| SwitchLabel |
|
| SwitchLabel.Constant |
|
| SwitchLabel.Default |
|
| SwitchLabel.EnumConstant |
|
| SwitchLabel.PartialVisitor<R> |
|
| SwitchLabel.Visitor<R> |
|
| SwitchStatement |
|
| Symbol |
Any symbol
|
| Symbol |
A Lisp symbol (identifier)
|
| SymmetricObjectProperty |
|
| SynchronizedStatement |
|
| Table<V> |
A simple table as in a CSV file, having an optional header row and any number of data rows
|
| TableType |
A type definition for a table, including column names and types
|
| Tabular |
Term decoders for hydra.tabular
|
| Tabular |
DSL functions for hydra.tabular
|
| Tabular |
Term encoders for hydra.tabular
|
| Tag |
A tag for categorizing test cases
|
| Tail |
Returns all elements except the first.
|
| TailArgs |
|
| Take |
Takes the first n elements.
|
| Tan |
Computes the tangent of an angle.
|
| Tanh |
Computes the hyperbolic tangent.
|
| TargetWithStarAtom |
|
| TargetWithStarAtom.Atom |
|
| TargetWithStarAtom.PartialVisitor<R> |
|
| TargetWithStarAtom.Project |
|
| TargetWithStarAtom.Slices |
|
| TargetWithStarAtom.Visitor<R> |
|
| TarjanState |
|
| TBinding<A> |
An association of a named term (element) with a phantom type
|
| Template |
|
| Templates |
A utility which instantiates a nonrecursive type with default values
|
| TemporalDurationFunctionFeatures |
Temporal duration functions
|
| TemporalInstantFunctionFeatures |
Temporal instant functions
|
| Term |
A data term
|
| Term |
|
| Term.Annotated |
A term annotated with metadata
|
| Term.Application |
A function application
|
| Term.Either |
An either value
|
| Term.Function |
A function term
|
| Term.Let |
A 'let' term, which binds variables to terms
|
| Term.List |
A list
|
| Term.Literal |
A literal value
|
| Term.Map |
A map of keys to values
|
| Term.Maybe |
An optional value
|
| Term.Pair |
A pair (2-tuple)
|
| Term.PartialVisitor<R> |
|
| Term.Record |
A record term
|
| Term.Set |
A set of values
|
| Term.TypeApplication |
A System F type application term
|
| Term.TypeLambda |
A System F type abstraction term
|
| Term.Union |
An injection; an instance of a union type
|
| Term.Unit |
A unit value; a term with no value
|
| Term.Variable |
A variable reference
|
| Term.Visitor<R> |
|
| Term.Wrap |
A wrapped term; an instance of a wrapper type (newtype)
|
| TermCoder<A> |
A type together with a coder for mapping terms into arguments for primitive functions, and mapping computed results into terms.
|
| TermDefinition |
A term-level definition, including a name, a term, and the type scheme of the term
|
| TerminatedTraversal |
|
| TermLhs |
|
| TermOp |
|
| TermOp.Div |
|
| TermOp.Floordiv |
|
| TermOp.Matmul |
|
| TermOp.Mod |
|
| TermOp.Mul |
|
| TermOp.PartialVisitor<R> |
|
| TermOp.Visitor<R> |
|
| TermRewriter |
A predefined term rewriter for testing rewriteTerm
|
| TermRewriter.PartialVisitor<R> |
|
| TermRewriter.ReplaceFooWithBar |
Replace all string literal 'foo' with 'bar'
|
| TermRewriter.ReplaceInt32WithInt64 |
Replace all Int32 literals with Int64 literals of the same value
|
| TermRewriter.Visitor<R> |
|
| Terms |
A domain-specific language for constructing Hydra terms in Java.
|
| TermsToElements |
Functions for mapping Hydra terms to property graph elements using mapping specifications
|
| TermSubst |
A substitution of term variables for terms
|
| TermVariableShadowingError |
A lambda parameter or let binding name that shadows a variable already in scope (optional)
|
| TermVariant |
The identifier of a term expression constructor
|
| TermVariant.Annotated |
|
| TermVariant.Application |
|
| TermVariant.Either |
|
| TermVariant.Function |
|
| TermVariant.Let |
|
| TermVariant.List |
|
| TermVariant.Literal |
|
| TermVariant.Map |
|
| TermVariant.Maybe |
|
| TermVariant.Pair |
|
| TermVariant.PartialVisitor<R> |
|
| TermVariant.Record |
|
| TermVariant.Set |
|
| TermVariant.TypeApplication |
|
| TermVariant.TypeLambda |
|
| TermVariant.Union |
|
| TermVariant.Unit |
|
| TermVariant.Variable |
|
| TermVariant.Visitor<R> |
|
| TermVariant.Wrap |
|
| TestCase |
A simple test case with an input and an expected output
|
| TestCase.AlphaConversion |
An alpha conversion test
|
| TestCase.CaseConversion |
A case conversion test
|
| TestCase.DeannotateTerm |
A deannotate term test
|
| TestCase.DeannotateType |
A deannotate type test
|
| TestCase.DelegatedEvaluation |
A delegated evaluation test
|
| TestCase.EtaExpansion |
An eta expansion test
|
| TestCase.Evaluation |
A term evaluation test
|
| TestCase.FlattenLetTerms |
A flatten let terms test
|
| TestCase.FoldOverTerm |
A fold over term test
|
| TestCase.FreeVariables |
A free variables test
|
| TestCase.HoistCaseStatements |
A hoist case statements test
|
| TestCase.HoistLetBindings |
A hoist all let bindings test (hoistAll=True, for Java)
|
| TestCase.HoistPolymorphicLetBindings |
A hoist polymorphic let bindings test
|
| TestCase.HoistSubterms |
A hoist subterms test
|
| TestCase.Inference |
A type inference test
|
| TestCase.InferenceFailure |
A type inference failure test
|
| TestCase.JoinTypes |
A join types test (produce type constraints)
|
| TestCase.JsonDecode |
A JSON decode test using Either-based decoder
|
| TestCase.JsonEncode |
A JSON encode test using Either-based encoder
|
| TestCase.JsonParser |
A JSON parser test
|
| TestCase.JsonRoundtrip |
A JSON round-trip test using Either-based encoder/decoder
|
| TestCase.JsonWriter |
A JSON writer test
|
| TestCase.LiftLambdaAboveLet |
A lift lambda above let test
|
| TestCase.NormalizeTypeVariables |
A normalize type variables test
|
| TestCase.PartialVisitor<R> |
|
| TestCase.RewriteTerm |
A rewrite term test
|
| TestCase.RewriteType |
A rewrite type test
|
| TestCase.Serialization |
An AST serialization test
|
| TestCase.SimplifyTerm |
A simplify term test
|
| TestCase.SubstInType |
A type substitution test
|
| TestCase.TopologicalSort |
A topological sort test
|
| TestCase.TopologicalSortBindings |
A topological sort bindings test
|
| TestCase.TopologicalSortSCC |
A topological sort with SCC detection test
|
| TestCase.TypeChecking |
A type checking test
|
| TestCase.TypeCheckingFailure |
A type checking failure test (currently unused)
|
| TestCase.TypeReduction |
A type reduction test
|
| TestCase.UnifyTypes |
A type unification test
|
| TestCase.UnshadowVariables |
An unshadow variables test
|
| TestCase.ValidateCoreTerm |
A core term validation test
|
| TestCase.VariableOccursInType |
An occur check test for type unification
|
| TestCase.Visitor<R> |
|
| TestCaseWithMetadata |
One of a number of test case variants, together with metadata including a test name, an optional description, and optional tags
|
| TestCodec |
A codec for generating compiled test files from test groups into a target programming language
|
| TestGenerator<A> |
A language-agnostic test generator abstraction, parameterized by the namespace/module name type
|
| TestGroup |
A collection of test cases with a name and optional description
|
| Testing |
Term decoders for hydra.testing
|
| Testing |
DSL functions for hydra.testing
|
| Testing |
Term encoders for hydra.testing
|
| Testing |
Haskell test code generation codec for HSpec-based generation tests
|
| Testing |
Java test code generation codec for JUnit-based generation tests
|
| Testing |
Python test code generation codec for pytest-based generation tests
|
| Throws |
|
| ThrowStatement |
|
| Time |
|
| ToArgs |
|
| ToArgs.Direction |
|
| ToArgs.PartialVisitor<R> |
|
| ToArgs.String_ |
|
| ToArgs.Traversal |
|
| ToArgs.Vertex |
|
| ToArgs.Visitor<R> |
|
| Token |
|
| ToList |
Converts a map to a list of pairs.
|
| ToList |
Converts a Maybe to a list: Just x becomes [x], Nothing becomes [].
|
| ToList |
Converts a set to a list of elements.
|
| ToList |
Converts a string to a list of character code points.
|
| ToLower |
Converts a character to lowercase.
|
| ToLower |
Converts a string to lowercase.
|
| TopLevelForm |
A top-level form in a Lisp program
|
| TopLevelForm.Constant |
A constant definition
|
| TopLevelForm.Expression |
A bare expression at the top level
|
| TopLevelForm.Function |
A named function definition
|
| TopLevelForm.Macro |
A macro definition
|
| TopLevelForm.PartialVisitor<R> |
|
| TopLevelForm.RecordType |
A record/struct type definition
|
| TopLevelForm.Variable |
A global variable definition
|
| TopLevelForm.Visitor<R> |
|
| TopLevelFormWithComments |
A top-level form together with optional documentation
|
| TopologicalSortBindingsTestCase |
A test case which performs topological sort on a map of bindings (name -> term) and compares the result with expected groups of bindings in topological order
|
| TopologicalSortSCCTestCase |
A test case which performs topological sort with strongly connected component detection and compares the result with expected components
|
| TopologicalSortTestCase |
A test case which performs topological sort on a directed graph and compares the result with either an expected sorted list or expected cycles
|
| Topology |
Term decoders for hydra.topology
|
| Topology |
DSL functions for hydra.topology
|
| Topology |
Term encoders for hydra.topology
|
| ToUpper |
Converts a character to uppercase.
|
| ToUpper |
Converts a string to uppercase.
|
| TPrimary |
|
| TPrimary.Atom |
|
| TPrimary.PartialVisitor<R> |
|
| TPrimary.PrimaryAndArguments |
|
| TPrimary.PrimaryAndGenexp |
|
| TPrimary.PrimaryAndName |
|
| TPrimary.PrimaryAndSlices |
|
| TPrimary.Visitor<R> |
|
| TPrimaryAndArguments |
|
| TPrimaryAndGenexp |
|
| TPrimaryAndName |
|
| TPrimaryAndSlices |
|
| TransactionPart |
|
| TransactionPart.Begin |
|
| TransactionPart.Commit |
|
| TransactionPart.PartialVisitor<R> |
|
| TransactionPart.Rollback |
|
| TransactionPart.Visitor<R> |
|
| Transform |
Functions for transforming property graph mappings into property graph elements.
|
| Transform |
Transform test cases for code generation, filtering to tests that can be compiled to target languages
|
| TransitiveObjectProperty |
|
| Transpose |
Transposes a matrix (list of lists).
|
| TraversalBiFunctionArgument |
|
| TraversalBiFunctionArgument.PartialVisitor<R> |
|
| TraversalBiFunctionArgument.Value |
|
| TraversalBiFunctionArgument.Variable |
|
| TraversalBiFunctionArgument.Visitor<R> |
|
| TraversalCardinality |
|
| TraversalCardinality.List |
|
| TraversalCardinality.PartialVisitor<R> |
|
| TraversalCardinality.Set |
|
| TraversalCardinality.Single |
|
| TraversalCardinality.Visitor<R> |
|
| TraversalCardinalityArgument |
|
| TraversalCardinalityArgument.PartialVisitor<R> |
|
| TraversalCardinalityArgument.Value |
|
| TraversalCardinalityArgument.Variable |
|
| TraversalCardinalityArgument.Visitor<R> |
|
| TraversalCardinalityArgumentAndObjects |
|
| TraversalColumn |
|
| TraversalColumn.Keys |
|
| TraversalColumn.PartialVisitor<R> |
|
| TraversalColumn.Values |
|
| TraversalColumn.Visitor<R> |
|
| TraversalColumnArgument |
|
| TraversalColumnArgument.PartialVisitor<R> |
|
| TraversalColumnArgument.Value |
|
| TraversalColumnArgument.Variable |
|
| TraversalColumnArgument.Visitor<R> |
|
| TraversalComparatorArgument |
|
| TraversalComparatorArgument.PartialVisitor<R> |
|
| TraversalComparatorArgument.Value |
|
| TraversalComparatorArgument.Variable |
|
| TraversalComparatorArgument.Visitor<R> |
|
| TraversalDirection |
|
| TraversalDirection.Both |
|
| TraversalDirection.In |
|
| TraversalDirection.Out |
|
| TraversalDirection.PartialVisitor<R> |
|
| TraversalDirection.Visitor<R> |
|
| TraversalDirectionArgument |
|
| TraversalDirectionArgument.PartialVisitor<R> |
|
| TraversalDirectionArgument.Value |
|
| TraversalDirectionArgument.Variable |
|
| TraversalDirectionArgument.Visitor<R> |
|
| TraversalDT |
|
| TraversalDT.Day |
|
| TraversalDT.Hour |
|
| TraversalDT.Minute |
|
| TraversalDT.PartialVisitor<R> |
|
| TraversalDT.Second |
|
| TraversalDT.Visitor<R> |
|
| TraversalDTArgument |
|
| TraversalDTArgument.PartialVisitor<R> |
|
| TraversalDTArgument.Value |
|
| TraversalDTArgument.Variable |
|
| TraversalDTArgument.Visitor<R> |
|
| TraversalFunction |
|
| TraversalFunction.Column |
|
| TraversalFunction.PartialVisitor<R> |
|
| TraversalFunction.Token |
|
| TraversalFunction.Visitor<R> |
|
| TraversalFunctionArgument |
|
| TraversalFunctionArgument.PartialVisitor<R> |
|
| TraversalFunctionArgument.Value |
|
| TraversalFunctionArgument.Variable |
|
| TraversalFunctionArgument.Visitor<R> |
|
| TraversalFunctionArgumentOrStringArgumentOrNestedTraversal |
|
| TraversalFunctionArgumentOrStringArgumentOrNestedTraversal.Function |
|
| TraversalFunctionArgumentOrStringArgumentOrNestedTraversal.PartialVisitor<R> |
|
| TraversalFunctionArgumentOrStringArgumentOrNestedTraversal.String_ |
|
| TraversalFunctionArgumentOrStringArgumentOrNestedTraversal.Traversal |
|
| TraversalFunctionArgumentOrStringArgumentOrNestedTraversal.Visitor<R> |
|
| TraversalMerge |
|
| TraversalMerge.InV |
|
| TraversalMerge.OnCreate |
|
| TraversalMerge.OnMatch |
|
| TraversalMerge.OutV |
|
| TraversalMerge.PartialVisitor<R> |
|
| TraversalMerge.Visitor<R> |
|
| TraversalMergeArgument |
|
| TraversalMergeArgument.PartialVisitor<R> |
|
| TraversalMergeArgument.Value |
|
| TraversalMergeArgument.Variable |
|
| TraversalMergeArgument.Visitor<R> |
|
| TraversalMergeArgumentAndGenericLiteralMapNullableArgument |
|
| TraversalMergeArgumentAndNestedTraversal |
|
| TraversalMethod |
|
| TraversalMethod.AddE |
|
| TraversalMethod.AddV |
|
| TraversalMethod.Aggregate |
|
| TraversalMethod.All |
|
| TraversalMethod.And |
|
| TraversalMethod.Any |
|
| TraversalMethod.As |
|
| TraversalMethod.AsDate |
|
| TraversalMethod.AsString |
|
| TraversalMethod.Barrier |
|
| TraversalMethod.Both |
|
| TraversalMethod.BothE |
|
| TraversalMethod.BothV |
|
| TraversalMethod.Branch |
|
| TraversalMethod.By |
|
| TraversalMethod.Call |
|
| TraversalMethod.Cap |
|
| TraversalMethod.Choose |
|
| TraversalMethod.Coalesce |
|
| TraversalMethod.Coin |
|
| TraversalMethod.Combine |
|
| TraversalMethod.Concat |
|
| TraversalMethod.Conjoin |
|
| TraversalMethod.ConnectedComponent |
|
| TraversalMethod.Constant |
|
| TraversalMethod.Count |
|
| TraversalMethod.CyclicPath |
|
| TraversalMethod.DateAdd |
|
| TraversalMethod.DateDiff |
|
| TraversalMethod.Dedup |
|
| TraversalMethod.Difference |
|
| TraversalMethod.Disjunct |
|
| TraversalMethod.Drop |
|
| TraversalMethod.E |
|
| TraversalMethod.Element |
|
| TraversalMethod.ElementMap |
|
| TraversalMethod.Emit |
|
| TraversalMethod.Fail |
|
| TraversalMethod.Filter |
|
| TraversalMethod.FlatMap |
|
| TraversalMethod.Fold |
|
| TraversalMethod.Format |
|
| TraversalMethod.From |
|
| TraversalMethod.Group |
|
| TraversalMethod.GroupCount |
|
| TraversalMethod.Has |
|
| TraversalMethod.HasId |
|
| TraversalMethod.HasKey |
|
| TraversalMethod.HasLabel |
|
| TraversalMethod.HasNot |
|
| TraversalMethod.HasValue |
|
| TraversalMethod.Id |
|
| TraversalMethod.Identity |
|
| TraversalMethod.In |
|
| TraversalMethod.Index |
|
| TraversalMethod.InE |
|
| TraversalMethod.Inject |
|
| TraversalMethod.Intersect |
|
| TraversalMethod.InV |
|
| TraversalMethod.Is |
|
| TraversalMethod.Key |
|
| TraversalMethod.Label |
|
| TraversalMethod.Length |
|
| TraversalMethod.Limit |
|
| TraversalMethod.Local |
|
| TraversalMethod.Loops |
|
| TraversalMethod.LTrim |
|
| TraversalMethod.Map |
|
| TraversalMethod.Match |
|
| TraversalMethod.Math_ |
|
| TraversalMethod.Max |
|
| TraversalMethod.Mean |
|
| TraversalMethod.Merge |
|
| TraversalMethod.MergeE |
|
| TraversalMethod.MergeV |
|
| TraversalMethod.Min |
|
| TraversalMethod.None |
|
| TraversalMethod.Not |
|
| TraversalMethod.Option |
|
| TraversalMethod.Optional |
|
| TraversalMethod.Or |
|
| TraversalMethod.Order |
|
| TraversalMethod.OtherV |
|
| TraversalMethod.Out |
|
| TraversalMethod.OutE |
|
| TraversalMethod.OutV |
|
| TraversalMethod.PageRank |
|
| TraversalMethod.PartialVisitor<R> |
|
| TraversalMethod.Path |
|
| TraversalMethod.PeerPressure |
|
| TraversalMethod.Product |
|
| TraversalMethod.Profile |
|
| TraversalMethod.Project |
|
| TraversalMethod.Properties |
|
| TraversalMethod.Property |
|
| TraversalMethod.PropertyMap |
|
| TraversalMethod.Range |
|
| TraversalMethod.Read |
|
| TraversalMethod.Repeat |
|
| TraversalMethod.Replace |
|
| TraversalMethod.Reverse |
|
| TraversalMethod.RTrim |
|
| TraversalMethod.Sack |
|
| TraversalMethod.Sample |
|
| TraversalMethod.Select |
|
| TraversalMethod.ShortestPath |
|
| TraversalMethod.SideEffect |
|
| TraversalMethod.SimplePath |
|
| TraversalMethod.Skip |
|
| TraversalMethod.Split |
|
| TraversalMethod.Store |
|
| TraversalMethod.Subgraph |
|
| TraversalMethod.Substring |
|
| TraversalMethod.Sum |
|
| TraversalMethod.Tail |
|
| TraversalMethod.Times |
|
| TraversalMethod.To |
|
| TraversalMethod.ToE |
|
| TraversalMethod.ToLower |
|
| TraversalMethod.ToUpper |
|
| TraversalMethod.ToV |
|
| TraversalMethod.Tree |
|
| TraversalMethod.Trim |
|
| TraversalMethod.Unfold |
|
| TraversalMethod.Union |
|
| TraversalMethod.Until |
|
| TraversalMethod.V |
|
| TraversalMethod.Value |
|
| TraversalMethod.ValueMap |
|
| TraversalMethod.Values |
|
| TraversalMethod.Visitor<R> |
|
| TraversalMethod.Where |
|
| TraversalMethod.With |
|
| TraversalMethod.Write |
|
| TraversalOperator |
|
| TraversalOperator.AddAll |
|
| TraversalOperator.And |
|
| TraversalOperator.Assign |
|
| TraversalOperator.Div |
|
| TraversalOperator.Max |
|
| TraversalOperator.Min |
|
| TraversalOperator.Minus |
|
| TraversalOperator.Mult |
|
| TraversalOperator.Or |
|
| TraversalOperator.PartialVisitor<R> |
|
| TraversalOperator.Sum |
|
| TraversalOperator.SumLong |
|
| TraversalOperator.Visitor<R> |
|
| TraversalOrder |
Specifies either a pre-order or post-order traversal
|
| TraversalOrder |
|
| TraversalOrder.Asc |
|
| TraversalOrder.Decr |
|
| TraversalOrder.Desc |
|
| TraversalOrder.Incr |
|
| TraversalOrder.PartialVisitor<R> |
|
| TraversalOrder.PartialVisitor<R> |
|
| TraversalOrder.Post |
Post-order traversal
|
| TraversalOrder.Pre |
Pre-order traversal
|
| TraversalOrder.Shuffle |
|
| TraversalOrder.Visitor<R> |
|
| TraversalOrder.Visitor<R> |
|
| TraversalOrderArgument |
|
| TraversalOrderArgument.PartialVisitor<R> |
|
| TraversalOrderArgument.Value |
|
| TraversalOrderArgument.Variable |
|
| TraversalOrderArgument.Visitor<R> |
|
| TraversalPick |
|
| TraversalPick.Any |
|
| TraversalPick.None |
|
| TraversalPick.PartialVisitor<R> |
|
| TraversalPick.Visitor<R> |
|
| TraversalPop |
|
| TraversalPop.All |
|
| TraversalPop.First |
|
| TraversalPop.Last |
|
| TraversalPop.Mixed |
|
| TraversalPop.PartialVisitor<R> |
|
| TraversalPop.Visitor<R> |
|
| TraversalPopArgument |
|
| TraversalPopArgument.PartialVisitor<R> |
|
| TraversalPopArgument.Value |
|
| TraversalPopArgument.Variable |
|
| TraversalPopArgument.Visitor<R> |
|
| TraversalPopArgumentAndNestedTraversal |
|
| TraversalPredicate |
|
| TraversalPredicate.And |
|
| TraversalPredicate.Between |
|
| TraversalPredicate.Containing |
|
| TraversalPredicate.EndingWith |
|
| TraversalPredicate.Eq |
|
| TraversalPredicate.Gt |
|
| TraversalPredicate.Gte |
|
| TraversalPredicate.Inside |
|
| TraversalPredicate.Lt |
|
| TraversalPredicate.Lte |
|
| TraversalPredicate.Negate |
|
| TraversalPredicate.Neq |
|
| TraversalPredicate.Not |
|
| TraversalPredicate.NotContaining |
|
| TraversalPredicate.NotEndingWith |
|
| TraversalPredicate.NotRegex |
|
| TraversalPredicate.NotStartingWith |
|
| TraversalPredicate.Or |
|
| TraversalPredicate.Outside |
|
| TraversalPredicate.PartialVisitor<R> |
|
| TraversalPredicate.Regex |
|
| TraversalPredicate.StartingWith |
|
| TraversalPredicate.Visitor<R> |
|
| TraversalPredicate.Within |
|
| TraversalPredicate.Without |
|
| TraversalPredicateAndNestedTraversal |
|
| TraversalPredicateOrGenericLiteralArgument |
|
| TraversalPredicateOrGenericLiteralArgument.Literal |
|
| TraversalPredicateOrGenericLiteralArgument.PartialVisitor<R> |
|
| TraversalPredicateOrGenericLiteralArgument.Predicate |
|
| TraversalPredicateOrGenericLiteralArgument.Visitor<R> |
|
| TraversalPredicateOrStringLiteralVarargs |
|
| TraversalPredicateOrStringLiteralVarargs.PartialVisitor<R> |
|
| TraversalPredicateOrStringLiteralVarargs.Predicate |
|
| TraversalPredicateOrStringLiteralVarargs.String_ |
|
| TraversalPredicateOrStringLiteralVarargs.Visitor<R> |
|
| TraversalSackMethodArgument |
|
| TraversalSackMethodArgument.PartialVisitor<R> |
|
| TraversalSackMethodArgument.Value |
|
| TraversalSackMethodArgument.Variable |
|
| TraversalSackMethodArgument.Visitor<R> |
|
| TraversalSackMethodArgumentOrIntegerArgument |
|
| TraversalSackMethodArgumentOrIntegerArgument.Consumer |
|
| TraversalSackMethodArgumentOrIntegerArgument.Int |
|
| TraversalSackMethodArgumentOrIntegerArgument.PartialVisitor<R> |
|
| TraversalSackMethodArgumentOrIntegerArgument.Visitor<R> |
|
| TraversalScope |
|
| TraversalScope.Global |
|
| TraversalScope.Local |
|
| TraversalScope.PartialVisitor<R> |
|
| TraversalScope.Visitor<R> |
|
| TraversalScopeArgument |
|
| TraversalScopeArgument.PartialVisitor<R> |
|
| TraversalScopeArgument.Value |
|
| TraversalScopeArgument.Variable |
|
| TraversalScopeArgument.Visitor<R> |
|
| TraversalSelfMethod |
|
| TraversalSelfMethod.Discard |
|
| TraversalSelfMethod.PartialVisitor<R> |
|
| TraversalSelfMethod.Visitor<R> |
|
| TraversalSource |
|
| TraversalSourceQuery |
|
| TraversalSourceSelfMethod |
|
| TraversalSourceSelfMethod.PartialVisitor<R> |
|
| TraversalSourceSelfMethod.Visitor<R> |
|
| TraversalSourceSelfMethod.With |
|
| TraversalSourceSelfMethod.WithBulk |
|
| TraversalSourceSelfMethod.WithoutStrategies |
|
| TraversalSourceSelfMethod.WithPath |
|
| TraversalSourceSelfMethod.WithSack |
|
| TraversalSourceSelfMethod.WithSideEffect |
|
| TraversalSourceSelfMethod.WithStrategies |
|
| TraversalSourceSpawnMethod |
|
| TraversalSourceSpawnMethod.AddE |
|
| TraversalSourceSpawnMethod.AddV |
|
| TraversalSourceSpawnMethod.Call |
|
| TraversalSourceSpawnMethod.E |
|
| TraversalSourceSpawnMethod.Inject |
|
| TraversalSourceSpawnMethod.Io |
|
| TraversalSourceSpawnMethod.MergeE |
|
| TraversalSourceSpawnMethod.MergeV |
|
| TraversalSourceSpawnMethod.PartialVisitor<R> |
|
| TraversalSourceSpawnMethod.Union |
|
| TraversalSourceSpawnMethod.V |
|
| TraversalSourceSpawnMethod.Visitor<R> |
|
| TraversalStrategy |
|
| TraversalTerminalMethod |
|
| TraversalTerminalMethod.Explain |
|
| TraversalTerminalMethod.HasNext |
|
| TraversalTerminalMethod.Iterate |
|
| TraversalTerminalMethod.Next |
|
| TraversalTerminalMethod.PartialVisitor<R> |
|
| TraversalTerminalMethod.ToBulkSet |
|
| TraversalTerminalMethod.ToList |
|
| TraversalTerminalMethod.ToSet |
|
| TraversalTerminalMethod.TryNext |
|
| TraversalTerminalMethod.Visitor<R> |
|
| TraversalToken |
|
| TraversalToken.Id |
|
| TraversalToken.Key |
|
| TraversalToken.Label |
|
| TraversalToken.PartialVisitor<R> |
|
| TraversalToken.Value |
|
| TraversalToken.Visitor<R> |
|
| TraversalTokenArgument |
|
| TraversalTokenArgument.PartialVisitor<R> |
|
| TraversalTokenArgument.Value |
|
| TraversalTokenArgument.Variable |
|
| TraversalTokenArgument.Visitor<R> |
|
| Tree |
|
| Tree.Bounds |
|
| Tree.CaseTree |
|
| Tree.Ctor |
|
| Tree.Enumerator |
|
| Tree.Importee |
|
| Tree.Importer |
|
| Tree.Member |
|
| Tree.Mod |
|
| Tree.PartialVisitor<R> |
|
| Tree.Pat |
|
| Tree.Quasi |
|
| Tree.Ref |
|
| Tree.Source |
|
| Tree.Stat |
|
| Tree.Template |
|
| Tree.Type |
|
| Tree.Visitor<R> |
|
| TrigonometricFunctionFeatures |
Trigonometric functions
|
| Triple |
An RDF triple defined by a subject, predicate, and object
|
| TripleConstraint |
|
| TripleExpression |
|
| TripleExprLabel |
|
| TripleExprLabel.BlankNode |
|
| TripleExprLabel.Iri |
|
| TripleExprLabel.PartialVisitor<R> |
|
| TripleExprLabel.Visitor<R> |
|
| TriplePattern |
A subject/predicate/object pattern
|
| Truncate |
Truncates the decimal part.
|
| TryExceptStarStatement |
|
| TryExceptStatement |
|
| TryFinallyStatement |
|
| TryStatement |
|
| TryStatement |
|
| TryStatement_Simple |
|
| TryStatement_WithFinally |
|
| TryStatement.Except |
|
| TryStatement.ExceptStar |
|
| TryStatement.Finally |
|
| TryStatement.PartialVisitor<R> |
|
| TryStatement.PartialVisitor<R> |
|
| TryStatement.Simple |
|
| TryStatement.Visitor<R> |
|
| TryStatement.Visitor<R> |
|
| TryStatement.WithFinally |
|
| TryStatement.WithResources |
|
| TryWithResourcesStatement |
|
| TTerm<A> |
An association of a term with a phantom type
|
| Tuple |
|
| TwoTraversalPredicates |
|
| Type |
A data type
|
| Type |
A type expression
|
| Type |
|
| Type |
|
| Type_And |
|
| Type_Annotate |
|
| Type_AnonymousName |
|
| Type_Apply |
|
| Type_ApplyInfix |
|
| Type_ByName |
|
| Type_ContextFunction |
|
| Type_Existential |
|
| Type_Function |
|
| Type_FunctionType |
|
| Type_FunctionType.ContextFunction |
|
| Type_FunctionType.Function |
|
| Type_FunctionType.PartialVisitor<R> |
|
| Type_FunctionType.Visitor<R> |
|
| Type_ImplicitFunction |
|
| Type_Lambda |
|
| Type_Macro |
|
| Type_Match |
|
| Type_Method |
|
| Type_Name |
|
| Type_Or |
|
| Type_Param |
|
| Type_Placeholder |
|
| Type_PolyFunction |
|
| Type_Project |
|
| Type_Ref |
|
| Type_Ref.Name |
|
| Type_Ref.PartialVisitor<R> |
|
| Type_Ref.Project |
|
| Type_Ref.Select |
|
| Type_Ref.Singleton |
|
| Type_Ref.Visitor<R> |
|
| Type_Refine |
|
| Type_Repeated |
|
| Type_Select |
|
| Type_Singleton |
|
| Type_Tuple |
|
| Type_TypedParam |
|
| Type_Var |
|
| Type_With |
|
| Type.And |
|
| Type.Annotate |
|
| Type.Annotated |
An annotated type
|
| Type.AnonymousName |
|
| Type.Application |
A type application
|
| Type.Application |
An application type
|
| Type.Apply |
|
| Type.ApplyInfix |
|
| Type.ByName |
|
| Type.Ctx |
A context type
|
| Type.Either |
An either (sum) type
|
| Type.Existential |
|
| Type.Forall |
A universally quantified (polymorphic) type
|
| Type.Function |
A function type
|
| Type.Function |
A function type
|
| Type.FunctionType |
|
| Type.ImplicitFunction |
|
| Type.Infix |
An infix type
|
| Type.Lambda |
|
| Type.List |
A list type
|
| Type.List |
A list type
|
| Type.Literal |
A literal type
|
| Type.Macro |
|
| Type.Map |
A map type
|
| Type.Match |
|
| Type.Maybe |
An optional type
|
| Type.Method |
|
| Type.Or |
|
| Type.Pair |
A pair (2-tuple) type
|
| Type.Parens |
A parenthesized type
|
| Type.PartialVisitor<R> |
|
| Type.PartialVisitor<R> |
|
| Type.PartialVisitor<R> |
|
| Type.PartialVisitor<R> |
|
| Type.Placeholder |
|
| Type.PolyFunction |
|
| Type.Primitive |
|
| Type.Record |
A record type
|
| Type.Ref |
|
| Type.Reference |
|
| Type.Refine |
|
| Type.Repeated |
|
| Type.Set |
A set type
|
| Type.Tuple |
A tuple type
|
| Type.Tuple |
|
| Type.TypedParam |
|
| Type.Union |
A union type with field names
|
| Type.Unit |
The unit type
|
| Type.Var |
|
| Type.Variable |
A type variable
|
| Type.Variable |
A type variable or type name
|
| Type.Visitor<R> |
|
| Type.Visitor<R> |
|
| Type.Visitor<R> |
|
| Type.Visitor<R> |
|
| Type.Void_ |
The void (uninhabited, or bottom) type
|
| Type.With |
|
| Type.Wrap |
A wrapped type (newtype)
|
| TypeAlias |
|
| TypeAnnotation |
An expression with a type annotation
|
| TypeApplicationTerm |
A term applied to a type; a type application
|
| TypeArgument |
|
| TypeArgument.PartialVisitor<R> |
|
| TypeArgument.Reference |
|
| TypeArgument.Visitor<R> |
|
| TypeArgument.Wildcard |
|
| TypeArgumentsOrDiamond |
|
| TypeArgumentsOrDiamond.Arguments |
|
| TypeArgumentsOrDiamond.Diamond |
|
| TypeArgumentsOrDiamond.PartialVisitor<R> |
|
| TypeArgumentsOrDiamond.Visitor<R> |
|
| TypeArityMismatchError |
A type constructor applied to the wrong number of type arguments
|
| TypeBound |
|
| TypeBound_ClassOrInterface |
|
| TypeBound.ClassOrInterface |
|
| TypeBound.PartialVisitor<R> |
|
| TypeBound.Variable |
|
| TypeBound.Visitor<R> |
|
| TypeBounds |
|
| TypeCase |
|
| TypeCheckingFailureTestCase |
A test case providing a term for which type checking is expected to fail.
|
| TypeCheckingTestCase |
A test case which performs type checking on a given term and compares the result with an expected annotated term and type
|
| TypeClass |
Any of a small number of built-in type classes
|
| TypeClass.Equality |
|
| TypeClass.Ordering |
|
| TypeClass.PartialVisitor<R> |
|
| TypeClass.Visitor<R> |
|
| TypeComment |
|
| TypeConstraint |
An assertion that two types can be unified into a single type
|
| TypedAssignment |
|
| TypedBinding |
A binding with its type signature
|
| TypeDeclaration |
A type synonym declaration
|
| TypeDeclaration |
|
| TypeDeclaration.Class_ |
|
| TypeDeclaration.Interface |
|
| TypeDeclaration.None |
|
| TypeDeclaration.PartialVisitor<R> |
|
| TypeDeclaration.Visitor<R> |
|
| TypeDeclarationWithComments |
|
| TypeDefinition |
A type-level definition, including a name and the type
|
| TypedPattern |
A typed pattern
|
| TypeExpression |
|
| TypeExpression.DoubleStarredExpression |
|
| TypeExpression.Expression |
|
| TypeExpression.PartialVisitor<R> |
|
| TypeExpression.StarredExpression |
|
| TypeExpression.Visitor<R> |
|
| TypeHint |
A type hint or annotation.
|
| TypeIdentifier |
|
| TypeImportOnDemandDeclaration |
|
| TypeLambda |
A System F type abstraction term
|
| TypeMismatchError |
A type mismatch between expected and actual types
|
| TypeName |
|
| TypeName |
|
| TypeNameArray |
|
| TypeNameArray.Array |
|
| TypeNameArray.PartialVisitor<R> |
|
| TypeNameArray.Simple |
|
| TypeNameArray.Visitor<R> |
|
| TypeParameter |
|
| TypeParameter |
|
| TypeParameter.DoubleStar |
|
| TypeParameter.PartialVisitor<R> |
|
| TypeParameter.Simple |
|
| TypeParameter.Star |
|
| TypeParameter.Visitor<R> |
|
| TypeParameterModifier |
|
| TypeReductionTestCase |
A test case which performs beta reduction on a type (reducing type applications) and compares the result with the expected type
|
| TypeRewriter |
A predefined type rewriter for testing rewriteType
|
| TypeRewriter.PartialVisitor<R> |
|
| TypeRewriter.ReplaceStringWithInt32 |
Replace all String types with Int32 types
|
| TypeRewriter.Visitor<R> |
|
| Types |
A domain-specific language for constructing Hydra types in Java.
|
| TypeScheme |
A type expression together with free type variables occurring in the expression
|
| TypeSignature |
A type signature
|
| TypeSignatureExpression |
A type signature expression
|
| TypeSpecifier |
A type specifier
|
| TypeSpecifier.Either |
An either/union type (two type specifiers)
|
| TypeSpecifier.Function |
A function type (params and return)
|
| TypeSpecifier.List |
A list type
|
| TypeSpecifier.Map |
A map type (key and value type specifiers)
|
| TypeSpecifier.Maybe |
An optional type
|
| TypeSpecifier.Named |
A named type reference
|
| TypeSpecifier.Pair |
A pair/tuple type (two type specifiers)
|
| TypeSpecifier.PartialVisitor<R> |
|
| TypeSpecifier.Set |
A set type
|
| TypeSpecifier.Unit |
The unit type
|
| TypeSpecifier.Visitor<R> |
|
| TypeSubst |
A substitution of type variables for types
|
| TypeVariable |
|
| TypeVariableMetadata |
Metadata associated with a type variable, including typeclass constraints
|
| TypeVariableShadowingInForallError |
A forall type parameter that shadows a type variable already in scope (optional)
|
| TypeVariableShadowingInTypeLambdaError |
A type lambda parameter that shadows a type variable already in scope (optional)
|
| TypeVariant |
The identifier of a type constructor
|
| TypeVariant.Annotated |
|
| TypeVariant.Application |
|
| TypeVariant.Either |
|
| TypeVariant.Forall |
|
| TypeVariant.Function |
|
| TypeVariant.List |
|
| TypeVariant.Literal |
|
| TypeVariant.Map |
|
| TypeVariant.Maybe |
|
| TypeVariant.Pair |
|
| TypeVariant.PartialVisitor<R> |
|
| TypeVariant.Record |
|
| TypeVariant.Set |
|
| TypeVariant.Union |
|
| TypeVariant.Unit |
|
| TypeVariant.Variable |
|
| TypeVariant.Visitor<R> |
|
| TypeVariant.Void_ |
|
| TypeVariant.Wrap |
|
| Typing |
Term decoders for hydra.typing
|
| Typing |
DSL functions for hydra.typing
|
| Typing |
Term encoders for hydra.typing
|
| Typing |
String representations of hydra.typing types
|
| Uchar |
|
| Uchar_Sequence |
|
| Uchar_Sequence2 |
|
| Uchar.PartialVisitor<R> |
|
| Uchar.Sequence |
|
| Uchar.Sequence2 |
|
| Uchar.Visitor<R> |
|
| Uint16ToBigint |
Primitive function which converts a uint16 (16-bit unsigned integer) to a bigint (arbitrary-precision integer).
|
| Uint32ToBigint |
Primitive function which converts a uint32 (32-bit unsigned integer) to a bigint (arbitrary-precision integer).
|
| Uint64ToBigint |
Primitive function which converts a uint64 (64-bit unsigned integer) to a bigint (arbitrary-precision integer).
|
| Uint8ToBigint |
Primitive function which converts a uint8 (8-bit unsigned integer) to a bigint (arbitrary-precision integer).
|
| UnannClassType |
A ClassType which does not allow annotations
|
| UnannType |
A Type which does not allow annotations
|
| UnaryAddOrSubtractExpression |
|
| UnaryExpression |
|
| UnaryExpression |
|
| UnaryExpression.Minus |
|
| UnaryExpression.Other |
|
| UnaryExpression.PartialVisitor<R> |
|
| UnaryExpression.Plus |
|
| UnaryExpression.PreDecrement |
|
| UnaryExpression.PreIncrement |
|
| UnaryExpression.Visitor<R> |
|
| UnaryExpressionNotPlusMinus |
|
| UnaryExpressionNotPlusMinus.Cast |
|
| UnaryExpressionNotPlusMinus.Not |
|
| UnaryExpressionNotPlusMinus.PartialVisitor<R> |
|
| UnaryExpressionNotPlusMinus.Postfix |
|
| UnaryExpressionNotPlusMinus.Tilde |
|
| UnaryExpressionNotPlusMinus.Visitor<R> |
|
| UnaryOperator |
|
| UnaryOperator.Negate |
|
| UnaryOperator.PartialVisitor<R> |
|
| UnaryOperator.Visitor<R> |
|
| UnaryTripleExpr |
|
| UnaryTripleExpr_Sequence |
|
| UnaryTripleExpr_Sequence_Alts |
|
| UnaryTripleExpr_Sequence_Alts.BracketedTripleExpr |
|
| UnaryTripleExpr_Sequence_Alts.PartialVisitor<R> |
|
| UnaryTripleExpr_Sequence_Alts.TripleConstraint |
|
| UnaryTripleExpr_Sequence_Alts.Visitor<R> |
|
| UnaryTripleExpr.Include |
|
| UnaryTripleExpr.PartialVisitor<R> |
|
| UnaryTripleExpr.Sequence |
|
| UnaryTripleExpr.Visitor<R> |
|
| UnboundTypeVariablesError |
Type variables that appear free in a type but are not bound in scope
|
| UndefinedFieldError |
A reference to a field that does not exist in the given type
|
| UndefinedTermVariableError |
A variable reference to a term name that is not bound in scope
|
| UndefinedTypeVariableError |
A type variable reference to a name that is not bound in scope
|
| UndefinedTypeVariableInBindingTypeError |
A type variable in a let binding's type scheme that is not bound by the scheme or enclosing scope
|
| UndefinedTypeVariableInLambdaDomainError |
A type variable in a lambda domain annotation that is not bound in scope
|
| UndefinedTypeVariableInTypeApplicationError |
A type variable in a type application term that is not bound in scope
|
| UnequalTypesError |
Multiple types that should all be equal but are not
|
| UnexpectedTermVariantError |
An unexpected term variant was encountered
|
| UnexpectedTypeVariantError |
An unexpected type variant was encountered
|
| Unification |
Utilities for type unification.
|
| UnificationError |
An error that occurred during type unification
|
| UnifyTypesTestCase |
A test case which attempts to unify two types and compares the result.
|
| Union |
|
| Union |
Computes the union of two sets.
|
| Union |
Computes the union of two sets.
|
| Unions |
Computes the union of multiple sets.
|
| Unit |
An empty record as a canonical unit value.
|
| UnknownPrimitiveNameError |
A primitive function reference to a name not in the known primitive registry
|
| Unlines |
Joins a list of strings with newlines and appends a final newline.
|
| UnnecessaryIdentityApplicationError |
An application of an identity lambda to an argument, which simplifies to the argument (optional)
|
| UnqualifiedClassInstanceCreationExpression |
|
| UnquoteExpression |
An unquoted form within a quasiquote: ~expr or ,expr
|
| UnshadowVariablesTestCase |
A test case which renames shadowed variables in a term and compares the result with the expected term
|
| UnsignedByte |
|
| UnsignedInt |
|
| UnsignedLong |
|
| UnsignedShort |
|
| UnsupportedTermVariantError |
A term variant that the type checker does not support
|
| UntypedAssignment |
|
| UntypedLambdaError |
A lambda expression without a type annotation on its parameter
|
| UntypedLetBindingError |
A let binding without a type annotation
|
| UntypedTermVariableError |
A term variable whose type is not known in the current scope
|
| Unwind |
|
| UpdateRecordExpression |
An update record expression
|
| UpdatingClause |
|
| UpdatingClause.Create |
|
| UpdatingClause.Delete |
|
| UpdatingClause.Merge |
|
| UpdatingClause.PartialVisitor<R> |
|
| UpdatingClause.Remove |
|
| UpdatingClause.Set |
|
| UpdatingClause.Visitor<R> |
|
| UpdatingFeatures |
Specific syntax related to updating data in the graph
|
| Util |
Term decoders for hydra.util
|
| Util |
DSL functions for hydra.util
|
| Util |
Term encoders for hydra.util
|
| Util |
Extraction and validation for hydra.util types
|
| Util |
String representations of hydra.util types
|
| Utils |
Utilities for working with Haskell syntax trees
|
| Utils |
Java utilities for constructing Java syntax trees
|
| Utils |
Python utilities for constructing Python syntax trees
|
| Utils |
Utility functions for working with RDF graphs and descriptions
|
| Utils |
Utility functions for constructing Scala AST nodes
|
| Utils |
Utility functions for GraphSON encoding and property graph conversion.
|
| Utils |
Utility functions for property graph operations
|
| Utils |
Shared utility functions for test code generation codecs
|
| Uuid |
|
| ValidateCoreTermTestCase |
A test case which validates a term and compares the result with an expected Maybe InvalidTermError
|
| Validation |
Utilities for validating property graphs against property graph schemas
|
| Value |
A JSON value
|
| Value |
|
| Value.Array |
A JSON array
|
| Value.BigDecimal |
|
| Value.BigInteger |
|
| Value.Binary |
|
| Value.Boolean_ |
A boolean value
|
| Value.Boolean_ |
|
| Value.Byte_ |
|
| Value.Char |
|
| Value.Composite |
|
| Value.DateTime |
|
| Value.Double_ |
|
| Value.Duration |
|
| Value.Float_ |
|
| Value.Integer_ |
|
| Value.List |
|
| Value.Long_ |
|
| Value.Map |
|
| Value.Null |
JSON's null value
|
| Value.Null |
|
| Value.Number_ |
A numeric value
|
| Value.Object_ |
A JSON object as a set of key/value pairs
|
| Value.PartialVisitor<R> |
|
| Value.PartialVisitor<R> |
|
| Value.Primitive |
|
| Value.Set |
|
| Value.Short_ |
|
| Value.String_ |
A string value
|
| Value.String_ |
|
| Value.Uuid |
|
| Value.Visitor<R> |
|
| Value.Visitor<R> |
|
| ValueBinding |
A value binding
|
| ValueBinding.PartialVisitor<R> |
|
| ValueBinding.Simple |
A simple value binding
|
| ValueBinding.Visitor<R> |
|
| ValueMapArgs |
|
| ValueMapArgs.Boolean_ |
|
| ValueMapArgs.PartialVisitor<R> |
|
| ValueMapArgs.String_ |
|
| ValueMapArgs.Visitor<R> |
|
| ValueMapBooleanArgs |
|
| ValuePair |
|
| ValuePattern |
|
| ValueSet |
|
| ValueSetValue |
|
| ValueSetValue.IriRange |
|
| ValueSetValue.Literal |
|
| ValueSetValue.PartialVisitor<R> |
|
| ValueSetValue.Visitor<R> |
|
| ValueSpec |
A mapping specification producing values (usually literal values) whose type is understood in context
|
| ValueSpec.PartialVisitor<R> |
|
| ValueSpec.Pattern |
A compact path representing the function, e.g.
|
| ValueSpec.Value |
A trivial no-op specification which passes the entire value
|
| ValueSpec.Visitor<R> |
|
| Variable |
|
| Variable |
A type variable
|
| Variable |
|
| Variable |
A query variable
|
| VariableAccess |
|
| VariableAccess.ExpressionName |
|
| VariableAccess.FieldAccess |
|
| VariableAccess.PartialVisitor<R> |
|
| VariableAccess.Visitor<R> |
|
| VariableAndNodeLabels |
|
| VariableArityParameter |
|
| VariableDeclarator |
|
| VariableDeclaratorId |
|
| VariableDefinition |
A global variable definition.
|
| VariableEquals |
|
| VariableFeatures |
Features for Graph.Variables.
|
| VariableInitializer |
|
| VariableInitializer.ArrayInitializer |
|
| VariableInitializer.Expression |
|
| VariableInitializer.PartialVisitor<R> |
|
| VariableInitializer.Visitor<R> |
|
| VariableModifier |
|
| VariableModifier.Annotation |
|
| VariableModifier.Final |
|
| VariableModifier.PartialVisitor<R> |
|
| VariableModifier.Visitor<R> |
|
| VariableOccursInTypeTestCase |
A test case which checks whether a type variable occurs in a type expression.
|
| VariablePlusEquals |
|
| VariableReference |
A reference to a variable by name
|
| Variants |
Term decoders for hydra.variants
|
| Variants |
DSL functions for hydra.variants
|
| Variants |
Term encoders for hydra.variants
|
| VectorFunctionFeatures |
Vector functions
|
| VectorLiteral |
A vector literal.
|
| Vertex |
|
| Vertex<V> |
A vertex
|
| VertexBuilder<V> |
A builder object for property graph vertices.
|
| VertexFeatures |
Features that are related to Vertex operations.
|
| VertexLabel |
|
| VertexLabel |
The label of a vertex.
|
| VertexPattern |
|
| VertexPropertyFeatures |
Features that are related to Vertex Property objects.
|
| VertexPropertyValue |
|
| VertexSpec |
A mapping specification producing vertices of a specified label
|
| VertexType<T> |
The type of a vertex
|
| VertexTypeBuilder<T> |
A builder object for property graph vertex types.
|
| VertexWithAdjacentEdges<V> |
A vertex together with any outgoing and/or incoming edges; a vertex object
|
| VoidInNonBottomPositionError |
TypeVoid appearing in a position where no value can be constructed, such as a record field, list element, map key/value, set element, pair component, or function codomain (optional)
|
| Where |
|
| WhereArgs |
|
| WhereArgs.PartialVisitor<R> |
|
| WhereArgs.Predicate |
|
| WhereArgs.String_ |
|
| WhereArgs.Traversal |
|
| WhereArgs.Visitor<R> |
|
| WhereWithPredicateArgs |
|
| WhileStatement |
|
| WhileStatement |
|
| WhileStatementNoShortIf |
|
| Wildcard |
|
| WildcardBounds |
|
| WildcardBounds.Extends |
|
| WildcardBounds.PartialVisitor<R> |
|
| WildcardBounds.Super |
|
| WildcardBounds.Visitor<R> |
|
| WildcardPattern |
A wildcard pattern that matches any value
|
| With |
|
| WithArgs |
|
| WithArgsKeys |
|
| WithArgsKeys.PartialVisitor<R> |
|
| WithArgsKeys.String_ |
|
| WithArgsKeys.Visitor<R> |
|
| WithArgsKeys.WithOption |
|
| WithArgsValues |
|
| WithArgsValues.Io |
|
| WithArgsValues.Object_ |
|
| WithArgsValues.PartialVisitor<R> |
|
| WithArgsValues.Visitor<R> |
|
| WithArgsValues.WithOptions |
|
| WithClause |
|
| WithItem |
|
| WithOptionKeys |
|
| WithOptionKeys.ConnectedComponent |
|
| WithOptionKeys.Io |
|
| WithOptionKeys.PageRank |
|
| WithOptionKeys.PartialVisitor<R> |
|
| WithOptionKeys.PeerPressure |
|
| WithOptionKeys.ShortestPath |
|
| WithOptionKeys.Visitor<R> |
|
| WithOptionKeys.WithOptionsIndexer |
|
| WithOptionKeys.WithOptionsTokens |
|
| WithOptionsValues |
|
| WithOptionsValues.All |
|
| WithOptionsValues.Ids |
|
| WithOptionsValues.Keys |
|
| WithOptionsValues.Labels |
|
| WithOptionsValues.List |
|
| WithOptionsValues.Map |
|
| WithOptionsValues.None |
|
| WithOptionsValues.PartialVisitor<R> |
|
| WithOptionsValues.Tokens |
|
| WithOptionsValues.Values |
|
| WithOptionsValues.Visitor<R> |
|
| WithStatement |
|
| WrappedTerm |
A term wrapped in a type name
|
| Writer |
JSON serialization functions using the Hydra AST
|
| WriterTestCase<A> |
A test case which writes a value to a string and compares it to the expected string
|
| Ws |
One of several classes of whitespace
|
| Ws.Break |
A line break
|
| Ws.BreakAndIndent |
A line break followed by indentation
|
| Ws.DoubleBreak |
Two line breaks
|
| Ws.None |
No whitespace
|
| Ws.PartialVisitor<R> |
|
| Ws.Space |
A single space
|
| Ws.Visitor<R> |
|
| XorExpression |
|
| XsFacet |
|
| XsFacet.NumericFacet |
|
| XsFacet.PartialVisitor<R> |
|
| XsFacet.StringFacet |
|
| XsFacet.Visitor<R> |
|
| YieldExpression |
|
| YieldExpression.From |
|
| YieldExpression.PartialVisitor<R> |
|
| YieldExpression.Simple |
|
| YieldExpression.Visitor<R> |
|
| YieldItem |
|
| YieldItems |
|
| YieldStatement |
|
| Zip |
Zips two lists into pairs.
|
| ZipWith |
Zips two lists with a function.
|