All Classes and Interfaces
Class
Description
Computes the absolute value of a number.
An edge in an accessor graph, connecting two nodes via a path
A graph of accessor nodes and edges, representing term access patterns
A node in an accessor graph, representing a term or subterm
A sequence of term accessors forming a path through a term
Term decoders for hydra.accessors
Term encoders for hydra.accessors
Utilities for working with term accessors.
Computes the arccosine of a value.
Computes the inverse hyperbolic cosine.
A two-level bidirectional encoder which adapts types to types and terms to terms
An evaluation context together with a source language and a target language
Convenience functions for working with Hydra coders.
Performs addition on two numbers.
An edge which is adjacent to a given vertex.
Aliases and context for Java code generation
A test case which performs alpha conversion (variable renaming) on a term and compares the result with the expected term
Modifies a key's value.
A pattern-matching alternative
Performs logical AND on two boolean values.
A term together with an annotation
A type together with an annotation
Utilities for reading and writing type and term annotations
A base class for utilities which convert ANTLR parse trees into domain-specific objects.
A term which applies a function to an argument
An application-style declaration head
An application expression
An application pattern
The type-level analog of an application term
An application type
Applies a function in a flow context.
Applies a function in a flow context.
Applies a function in a flow context.
Functions dealing with arguments and arity.
Computes the arcsine of a value.
Computes the inverse hyperbolic sine.
An 'as' pattern
A type assertion
A class assertion
A tuple of assertions
Operator associativity
Term decoders for hydra.ast
Term encoders for hydra.ast
Gets the element at the specified index of a list.
Computes the arctangent of a value.
Computes the arctangent of y/x.
Computes the inverse hyperbolic tangent.
A two-level encoder and decoder, operating both at a type level and an instance (data) level
Primitive function which converts a bigfloat (arbitrary-precision decimal) to a bigint (arbitrary-precision integer).
Primitive function which converts a bigfloat (arbitrary-precision decimal) to a float32 (32-bit floating-point).
Primitive function which converts a bigfloat (arbitrary-precision decimal) to a float64 (64-bit floating-point).
Primitive function which converts a bigint (arbitrary-precision integer) to a bigfloat (arbitrary-precision decimal).
Primitive function which converts a bigint (arbitrary-precision integer) to an int16 (16-bit signed integer).
Primitive function which converts a bigint (arbitrary-precision integer) to an int32 (32-bit signed integer).
Primitive function which converts a bigint (arbitrary-precision integer) to an int64 (64-bit signed integer).
Primitive function which converts a bigint (arbitrary-precision integer) to an int8 (8-bit signed integer).
Primitive function which converts a bigint (arbitrary-precision integer) to a uint16 (16-bit unsigned integer).
Primitive function which converts a bigint (arbitrary-precision integer) to a uint32 (32-bit unsigned integer).
Primitive function which converts a bigint (arbitrary-precision integer) to a uint64 (64-bit unsigned integer).
Primitive function which converts a bigint (arbitrary-precision integer) to a uint8 (8-bit unsigned integer).
Map over both sides of an Either value.
Transforms both keys and values.
Map over both elements of a pair.
Primitive function which converts binary data to a string.
Bind (flatMap) for Either: sequence an Either with a function that returns Either.
Monadic bind for flows.
Monadic bind for flows.
Monadic bind for optional values (flatMap).
A field with an optional type scheme, used to bind variables to terms in a 'let' expression
Formatting option for code blocks
Bootstrapping entry point: loads Hydra modules from JSON and generates
code for a target language.
A module which provides a minimal typing environment for decoding other modules from JSON.
An expression enclosed by brackets
Matching open and close bracket symbols
A naming convention for symbols, such as camelCase or snake_case
A test case which checks that strings are converted between different case conventions correctly
A case expression
The right-hand side of a pattern-matching alternative
Pattern matches on Maybe.
A union elimination; a case statement
Filters and extracts Just values.
Concatenates a list of strings into a single string.
Concatenates two strings.
Rounds up to the nearest integer.
Retrieves the character at a given index in a string.
DSL interface providing character primitive operations.
Type checking and type reconstruction (type-of) for the results of Hydra unification and inference
A class assertion
Term decoders for hydra.classes
Term encoders for hydra.classes
Pure code generation pipeline for bootstrapping Hydra across languages.
An encoder and decoder; a bidirectional flow between two types
Functions for encoding Hydra modules as Haskell modules
Java code generator: converts Hydra modules to Java source code
JSON encoding and decoding for Hydra terms
Python code generator: converts Hydra modules to Python source code
Indicates either the 'out' or the 'in' direction of a coder
Convenience functions for working with Hydra coders.
Term decoders for hydra.coders
Term encoders for hydra.coders
Common utilities for language coders, providing shared patterns for term decomposition and analysis.
A name for a domain which serves to identify the role played by that domain in the given relation; a 'role name' in Codd
An abstract specification of the domain represented by a column in a relation; a role
A column type, consisting of a name and a value type
Compares two values and returns a Comparison (LessThan, EqualTo, or GreaterThan).
An equality judgement: less than, equal to, or greater than
One of several comparison operators
Composes two Maybe-returning functions.
Term decoders for hydra.compute
Term encoders for hydra.compute
Concatenates a list of lists.
Concatenates two lists.
Prepends an element to a list.
A constant pattern
A module for tier-0 constants.
Term decoders for hydra.constraints
Term encoders for hydra.constraints
A data constructor
An ordinary (positional) constructor
A record constructor
A data constructor together with any comments
A record constructor expression
A type with a context (type class constraints)
Term decoders for hydra.core
Core DSL utilities for working with basic Hydra constructs.
Term encoders for hydra.core
Extraction and validation for hydra.core types
String representations of hydra.core types
Computes the cosine of an angle.
Computes the hyperbolic cosine.
This class provides an empty implementation of
CypherVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.A parser which constructs Cypher queries using the hydra.ext.cypher.openCypher model.
This interface defines a complete generic visitor for a parse tree produced
by
CypherParser.A data type declaration
The 'data' versus 'newtype keyword
A data row, containing optional-valued cells; one per column
A test case which strips all annotations from a term and compares the result with the expected term
A test case which strips all annotations from a type and compares the result with the expected type
A data or value declaration
A data type declaration
A type synonym declaration
A typed binding
A value binding
The left-hand side of a declaration
An application-style declaration head
A parenthesized declaration head
A simple name
A data declaration together with any comments
JSON decoding for Hydra terms.
Functions for generating term decoders from type modules
Decoding functions for JSON data
An error that occurred during decoding of a term
A definition, which may be either a term or type definition
A term definition
A type definition
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
Removes a key from the map.
Removes an element from a set.
A 'deriving' statement
A graph of RDF statements together with a distinguished subject and/or object node
Computes the set difference.
The direction of an edge or edge pattern
Performs division on two numbers.
Drops the first n elements.
Drops elements while predicate is true.
Returns the mathematical constant e.
An edge
An abstract edge based on a record type
A builder object for property graph edges.
The label of an edge
The type of an edge
A builder object for property graph edge types.
Eliminate an Either value by applying one of two functions.
A simple class for disjoint unions (Either types) in Java.
A Left value in an Either.
Partial visitor interface with a default case for non-exhaustive matching.
A Right value in an Either.
Visitor interface for pattern matching on Either values.
DSL interface providing either primitive operations.
Evaluation-level implementations of Either functions for the Hydra interpreter.
A type which provides a choice between a 'left' type and a 'right' type
Checks if an element is in a list.
Either a vertex or an edge
Abstract base class for building property graph elements (vertices or edges) with properties.
The kind of an element: vertex or edge
An element together with its dependencies in some context
The type of a vertex or edge
Abstract base class for building property graph element types (vertex types or edge types) with property types.
An element type together with its dependencies in some context
Returns all values.
A corresponding elimination for an introduction term
Eliminates a record by projecting a given field
Eliminates a union term by matching over the fields of the union.
Unwrap a wrapped term
The identifier of an elimination constructor
Creates an empty map.
Creates an empty set.
JSON encoding for Hydra terms.
Functions for generating term encoders from type modules
Tests equality.
DSL interface providing equality and comparison primitive operations.
A test case which performs eta expansion (adding missing lambda abstractions) on a given term and compares the result with the expected result
One of two evaluation styles: eager or lazy
A test case which evaluates (reduces) a given term and compares it with the expected result
Determines whether an integer is even.
Computes e raised to a power.
Functions for decoding of native Java values from Hydra terms.
An export statement
An exported declaration
An exported module
An abstract expression
A bracketed expression
A constant symbol
An indented expression
An operator expression
A data expression
A function application
A case expression
A record constructor expression
A 'do' expression
An 'if' expression
An infix application
A lambda expression
A left section expression
A 'let' expression
A list expression
A literal value
A parenthesized expression
A prefix application
A right section expression
A tuple expression
A type signature expression
A record update expression
A variable reference
Creates a failed flow.
A name/term pair
A field (name/type pair)
A name/type pair
A field name and value
A field together with any comments
A file extension (without the dot), e.g.
Filters a list, keeping only elements that satisfy the predicate.
Filters map entries by value.
Filters map entries by key and value.
Finds the first element in a list that satisfies the predicate.
Looks up with a default value.
Extracts the first element of a pair.
A test case which flattens nested let terms, lifting inner bindings to the outer let, and compares the result with the expected term
Primitive function which converts a float32 (32-bit floating-point) to a bigfloat (arbitrary-precision decimal).
Primitive function which converts a float64 (64-bit floating-point) to a bigfloat (arbitrary-precision decimal).
Note: this is an approximation which ignores encoding
A floating-point type
An arbitrary-precision floating-point type
A 32-bit floating-point type
A 64-bit floating-point type
A floating-point literal value
An arbitrary-precision floating-point value
A 32-bit floating-point value
A 64-bit floating-point value
Rounds down to the nearest integer.
A variant of the State monad with built-in logging and error handling
Exception thrown when a flow computation fails.
A collection of convenience methods for constructing and composing flows, or stateful computations.
DSL interface providing flow primitive operations for working with monadic computations.
Evaluation-level implementations of Flow functions for the Hydra interpreter.
The result of evaluating a Flow
Left fold with flow function.
Left-associative fold of a list with a binary function and initial value.
A predefined fold operation for testing foldOverTerm
Collect labels (first element of pairs where first is a string literal)
Collect the lengths of all list terms (returns list of integers in traversal order)
Sum all Int32 literals in a term
A test case which applies a fold operation over a term and compares the result
A universally quantified type; the System F equivalent of a type scheme, and the type-level equivalent of a lambda term.
A mapping from certain columns of a source relation to primary key columns of a target relation
String formatting types and functions.
A test case which computes the free variables of a term and compares the result with an expected set of names
Mapper from Cypher (OpenCypher) query model to property graph query model.
Extracts the value from Just.
Extract the Left value from an Either, or return a default value.
Creates a map from a list of pairs.
Creates a set from a list of elements.
Converts a list of character code points to a string.
Extracts the value from an optional, or returns a default if Nothing.
Extract the Right value from an Either, or return a default value.
A function
An elimination for any of a few term variants
A function abstraction (lambda)
A reference to a built-in (primitive) function
A functional interface representing a function that accepts three arguments and produces a result.
A functional interface representing a function that accepts four arguments and produces a result.
A structured representation of a function term's components, replacing ad-hoc tuples.
A function type, also known as an arrow type
A function type
The identifier of a function constructor
I/O wrapper for Hydra code generation in Java.
This class provides an empty implementation of
GQLVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.A parser for GQL (Graph Query Language) queries.
Exception thrown when GQL syntax errors are encountered during parsing.
This interface defines a complete generic visitor for a parse tree produced
by
GQLParser.Term decoders for hydra.grammar
Term encoders for hydra.grammar
An enhanced Backus-Naur form (BNF) grammar
A utility for converting a BNF grammar to a Hydra module.
A graph, or set of name/term bindings together with parameters (annotations, primitives) and a schema graph
A graph; a self-contained collection of vertices and edges
String representations of hydra.graph types
A query pattern which matches within a designated component subgraph
DSL for constructing property graph types (vertex and edge types, property types)
and values (vertices, edges, and properties).
A graph schema; a vertex and edge types for the vertices and edges of a graph conforming to the schema
Groups consecutive equal elements.
Tests if the first value is greater than the second.
Tests if the first value is greater than or equal to the second.
Returns the first element of a list.
A header row, containing column names (but no types or data)
Helper functions for decoding terms to domain types
A test case for the hoistCaseStatements function, which hoists case statements into let bindings, but only when they appear inside a lambda body.
Functions for deep term rewriting operations involving hoisting subterms or bindings into enclosing let terms.
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.
A test case for the hoistPolymorphicLetBindings function, which hoists polymorphic let bindings to the top level of a let term.
A predefined predicate for testing hoistSubterms.
Hoist function applications that appear in non-top-level positions
Hoist case statements (elimination unions) that appear in non-top-level positions
Hoist list terms that appear in non-top-level positions
Never hoist anything (identity transformation for let terms)
A test case which hoists subterms into let bindings based on a predicate, and compares the result with the expected term.
The specification of a Hydra schema, provided as a set of modules and a distinguished type
Base class for Hydra test utilities providing common assertion methods.
Returns its argument unchanged.
Performs conditional branching based on a boolean condition.
An 'if' expression
An import statement
An import or export specification
An import modifier ('pattern' or 'type')
An expression indented in a certain style
Any of several indentation styles
Indent all lines with the given string
Indent only lines after the first with the given string
Type inference following Algorithm W, extended for nominal terms and types
The context provided to type inference, including various typing environments.
A test case providing a term for which type inference is expected to fail
The result of applying inference rules to a term.
A test case which performs type inference on a given term and compares the result with an expected type scheme
An infix application expression
An infix type application
Returns all elements except the last.
An instance of a union type; i.e.
Adds an element to a set.
Adds an element to a set.
Primitive function which converts an int16 (16-bit signed integer) to a bigint (arbitrary-precision integer).
Primitive function which converts an int32 (32-bit signed integer) to a bigint (arbitrary-precision integer).
Primitive function which converts an int64 (64-bit signed integer) to a bigint (arbitrary-precision integer).
Primitive function which converts an int8 (8-bit signed integer) to a bigint (arbitrary-precision integer).
Note: this is an approximation which ignores encoding
An integer type
An arbitrary-precision integer type
A 16-bit signed integer type
A 32-bit signed integer type
A 64-bit signed integer type
An 8-bit signed integer type
A 16-bit unsigned integer type
A 32-bit unsigned integer type
A 64-bit unsigned integer type
An 8-bit unsigned integer type
An integer literal value
An arbitrary-precision integer value
A 16-bit signed integer value (short value)
A 32-bit signed integer value (int value)
A 64-bit signed integer value (long value)
An 8-bit signed integer value
A 16-bit unsigned integer value
A 32-bit unsigned integer value (unsigned int)
A 64-bit unsigned integer value (unsigned long)
An 8-bit unsigned integer value (byte)
Joins lists with a separator.
Joins a list of strings with a delimiter string.
Computes the intersection of two sets.
Inserts an element between list elements.
An Internationalized Resource Identifier
An IRI or a literal; this type is a convenience for downstream models like SHACL which may exclude blank nodes
Determines whether a character is alphanumeric (a letter or digit).
Checks if a map is empty.
Checks if a set is empty.
Determines whether a string is empty.
Checks if value is Just.
Check if an Either value is a Left.
Determines whether a character is lowercase.
Checks if value is Nothing.
Check if an Either value is a Right.
Determines whether a character is whitespace.
Determines whether a character is uppercase.
Environment for Java code generation
Feature flags for the target Java version
Classification of a Java symbol for code generation
A constant value
A hoisted lambda wrapped in type lambdas.
A local variable
A nullary function (no arguments)
A unary function (single argument)
A test case which joins two types (producing type constraints or failing).
Term decoders for hydra.json
Term encoders for hydra.json
Utilities for extracting values from JSON objects
A test case which encodes a Hydra term to JSON using a type-directed coder, and verifies that decoding produces the original term (round-trip)
A test case for the Either-based JSON decoder.
Decoding functions for Hydra's native JSON values which are intended for use in Java.
Exception thrown when JSON decoding fails.
A test case for the Either-based JSON encoder.
Encoding functions for Hydra's native JSON values.
Builder class for constructing JSON objects.
A bidirectional coder between Hydra's native JSON values and the JSON objects supported by json-io.
A test case for round-trip encoding/decoding using the Either-based JSON functions.
A bidirectional coder between Hydra's native JSON values and strings (via json-io).
Returns all keys.
A name for a pattern
Either a vertex or edge label
A pattern together with a name (label)
A function abstraction (lambda)
A lambda expression
A convenience type which provides at most one string value per language, and optionally a value without a language
A named language together with language-specific constraints
Language constraints and reserved words for Haskell
Language constraints and reserved words for Java
Language constraints for JSON
Language constraints and reserved words for Python 3
A set of constraints on valid type and term expressions, characterizing a language
The unique name of a language
Language constraints for Hydra Core
A BCP47 language tag
Returns the last element of a list.
The last mile of a transformation, which encodes and serializes terms to a file
A memoizing supplier that evaluates its value at most once.
A graph which does not assume that vertex or edge ids are unique.
Extract all Left values from a list of Eithers.
Returns the length of a list.
Returns the length of a string.
A set of (possibly recursive) 'let' bindings together with a body in which they are bound
A 'let' expression
Lexical functions (which deal with named elements and primitives within graphs).
A module for lexical operations over graphs.
A registry of all of the primitive functions available in Hydra-Java.
A library of primitive functions
A test case which lifts lambda abstractions above let expressions and compares the result with the expected term
Splits a string into lines by breaking at newline characters.
DSL interface providing list primitive operations.
Evaluation-level implementations of List functions for the Hydra interpreter.
A term constant; an instance of a literal type
A literal value
A value such as a string, number, or date
A binary literal
A boolean literal
A character literal
A double-precision floating point literal
A floating-point literal
A single-precision floating point literal
A 32-bit integer literal
An integer literal
An arbitrary-precision integer literal
A string literal
A string literal
Adapter framework for literal types and terms
DSL functions for working with literal values.
DSL interface providing literal primitive operations for type conversions and parsing/showing values.
Conversion functions for literal values.
Any of a fixed set of literal types, also called atomic types, base types, primitive types, or type constants
The type of a binary (byte string) value
The type of a boolean (true/false) value
The type of a floating-point value
The type of an integer value
The type of a string value
DSL utilities for working with literal types.
The identifier of a literal constructor
A simple tail-sharing linked list.
A local binding
A type signature
A value binding
A collection of local bindings
Computes the natural logarithm.
Computes the logarithm with a specified base.
DSL interface providing logic primitive operations.
Looks up a value by key.
Tests if the first value is less than the second.
Tests if the first value is less than or equal to the second.
Map a function over the Right side of an Either value.
Maps a function over a flow.
Applies a function to each element of a list, returning a new list of results.
Maps a function over a flow.
Maps a function over a flow.
Maps a function over all elements in a set.
Maps a flow function over map values.
Maps a flow function over map keys.
Maps a flow function over map keys.
Map a function that may fail over a list, collecting results or returning the first error.
Maps a flow function over a list.
Map a function that may fail over a Maybe, collecting results or returning the first error.
Maps a flow function over Maybe.
Maps a flow function over Maybe.
A base class for simple functional mappers with exceptions (specific to Java).
Exception thrown by mapper operations when invalid data is encountered.
DSL interface providing map primitive operations.
Evaluation-level implementations of Map functions for the Hydra interpreter.
Maps a flow function over a set.
A map type
DSL interface providing mathematical primitive operations.
Returns the maximum of two values.
Returns the maximum of two numbers.
Pattern matches with a default.
A Hydra binary labeled union type, similar to java.util.Optional.
DSL interface providing Maybe/Optional primitive operations for working with optional values.
Evaluation-level implementations of Maybe functions for the Hydra interpreter.
Checks if an element is in a set.
Checks if an element is in a set.
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.
A helper object which defines merged vertex and edge id types, and a value coder for each vertex and edge label.
String representations of hydra.meta types
Returns the minimum of two values.
Returns the minimum of two numbers.
Computes the modulo of two integers.
Term decoders for hydra.json.model
Term encoders for hydra.json.model
Term decoders for hydra.module
Term encoders for hydra.module
A Haskell module
A logical collection of elements in the same namespace, having dependencies on zero or more other modules
A builder for creating Hydra modules.
A module head
A module name
Entry point for Hydra's adapter (type/term rewriting) framework
Utilities for working with Hydra modules.
Functions for working with Hydra's 'flow' and other monads.
Performs multiplication on two numbers.
A unique identifier in some context; a string-valued key
A name
An implicit name
A normal name
A parenthesized name
A component of a qualified name
Java naming constants and package name utilities
Python naming utilities: encoding Hydra names as Python names
Functions for working with qualified names.
A prefix for element names
A mapping from namespaces to values of type n, with a focus on one namespace
Negates a number.
A YAML node (value)
A node in a query expression; it may be a term, a variable, or a wildcard
A mapping from nodes to nodes
A scalar value
A sequence of nodes
A graph term; an expression which is valid in the graph being matched
A query variable, not to be confused with a variable term
An anonymous variable which we do not care to join across patterns
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
Performs logical negation on a boolean value.
Removes duplicate elements.
Checks if a list is empty.
Checks if a map is empty (null in Haskell terminology).
Checks if a set is empty (null check).
Determines whether a string is empty (null check).
Determines whether an integer is odd.
An operator symbol
An operator
A function used as an infix operator
A normal infix operator
AST operators for Haskell
An operator expression
Performs logical OR on two boolean values.
An ordinary (positional) data constructor
Left and right padding for an operator
A simple class for pairs in Java.
DSL interface providing pair primitive operations.
Evaluation-level implementations of Pair functions for the Hydra interpreter.
A type which pairs a 'first' type and a 'second' type
An error which occurred while parsing
JSON parser using Hydra parser combinators
A parser which consumes characters from a string and produces a value
The result of a parse operation
A failed parse, with an error message and the remaining input
A successful parse, with a value and the remaining unparsed input
General-purpose parser combinators
A test case which parses an input string and compares the result with an expected value
A successful parse result
Term decoders for hydra.parsing
Term encoders for hydra.parsing
Partitions a list based on a predicate.
Partition a list of Eithers into separate lists of Left and Right values.
A query path
A path given by the inverse of another path
A path given by a regular expression quantifier applied to another path
A path given by a single step
A declared equivalence between two abstract paths in a graph
A pattern
A pattern which matches valid expressions in the language
A query pattern
A choice between alternative patterns
An application pattern
An 'as' pattern
The conjunction ('and') of several other patterns
A constant (terminal) pattern
The disjunction (inclusive 'or') of several other patterns
A pattern which matches within a named subgraph
A pattern to be ignored (not captured)
A labeled pattern
A list pattern
A literal pattern
A name pattern
The negation of another pattern
An empty pattern
A nonterminal symbol reference
An optional pattern (zero or one occurrence)
A parenthesized pattern
One or more occurrences of a pattern
A record pattern
A regular expression pattern
A sequence of patterns
Zero or more occurrences of a pattern
A subject/predicate/object pattern
A tuple pattern
A typed pattern
A wildcard pattern
A pattern field
A pattern which, if it matches in a given graph, implies that another pattern must also match.
Term decoders for hydra.phantoms
Term encoders for hydra.phantoms
Returns the mathematical constant pi.
A convenient wrapper for a stateless Flow, providing fluent-style methods.
A convenient wrapper for a stateless Flow, providing fluent-style methods.
Raises a number to a power.
Operator precedence
Numeric precision: arbitrary precision, or precision to a specified number of bits
Arbitrary precision
Precision to a specified number of bits
Returns the predecessor of an integer.
A prefix expression
A temporary pretty-printer for terms, for the sake of tests and debugging.
A primary key of a relation, specified either as a single column, or as a list of columns
A built-in function
Any of Hydra's primitive functions, implemented in Java.
A wrapper for a type which can be used as the basis of equality and comparison primitives.
A BNF production
A record elimination; a projection
A type representing an RDF property, and encapsulating its domain, range, and subclass relationships
A key/value property
A property key
The type of a property
Wraps a value in a flow.
Wraps a value in a flow.
Wraps a value in a flow.
Combined graph and metadata state for Python code generation
Environment for Python code generation
Temporary metadata used to create the header section of a Python file
Target Python version for code generation
An RDF triple with an optional named graph component
A qualified name
A qualified name consisting of an optional namespace together with a mandatory local name
DSL for constructing property graph queries.
Term decoders for hydra.query
Term encoders for hydra.query
A SELECT-style graph pattern matching query
Generates a range of integers.
A range from min to max, inclusive
Stand-in for rdfs:Class
Primitive function which parses a string into a bigfloat (arbitrary-precision decimal).
Primitive function which parses a string into a bigint (arbitrary precision integer).
Primitive function which parses a string into a boolean.
Primitive function which parses a string into a float32 (32-bit floating-point).
Primitive function which parses a string into a float64 (64-bit floating-point).
Primitive function which parses a string into an int16 (16-bit signed integer).
Primitive function which parses a string into an int32 (32-bit signed integer).
Primitive function which parses a string into an int64 (64-bit signed integer).
Primitive function which parses a string into an int8 (8-bit signed integer).
Primitive function which parses a string literal representation into a string value.
Primitive function which parses a string into a uint16 (16-bit unsigned integer).
Primitive function which parses a string into a uint32 (32-bit unsigned integer).
Primitive function which parses a string into a uint64 (64-bit unsigned integer).
Primitive function which parses a string into a uint8 (8-bit unsigned integer).
A record, or labeled tuple; a map of field names to terms
A record-style data constructor
A record pattern
Functions for reducing terms and types, i.e.
Reflection functions for working with term, type, and literal type variants, as well as numeric precision.
A regular expression
A regular expression quantifier
The {n,} quantifier; matches at least n occurrences
The {n} quantifier; matches exactly n occurrences
No quantifier; matches a single occurrence
The + quantifier; matches one or more occurrences
The {n, m} quantifier; matches between n and m (inclusive) occurrences
The * quantifier; matches any number of occurrences
The ? quanifier; matches zero or one occurrence
A path with a regex quantifier
A set of distinct n-tuples; a table
Term decoders for hydra.relational
Term encoders for hydra.relational
A unique relation (table) name
An abstract relation; the name and columns of a relation without its actual data
A domain-unordered (string-indexed, rather than position-indexed) relation
Computes the remainder of integer division.
Creates a list of n copies.
Reverses a list.
A test case which applies a term rewriter and compares the result
A test case which applies a type rewriter and compares the result
Utilities for type and term rewriting and analysis.
A right-hand side of a binding
Extract all Right values from a list of Eithers.
Rounds to the nearest integer.
An n-tuple which is an element of a given relation
A labeled record or union type
Safely returns the first element.
A union of scalars supported in the YAML failsafe and JSON schemas.
Represents a true/false value
Represents an approximation to real numbers
Represents arbitrary sized finite mathematical integers
Represents the lack of a value
A string value
Various functions for dereferencing and decoding schema types.
The specification of a schema at the source end of a workflow
A schema provided as a file, available at the given file path
A native Hydra schema
A schema which will be provided within the workflow
Extracts the second element of a pair.
A section expression
Sequences a list of flows.
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.
Java serializer: converts Java AST to concrete syntax
Python serializer: converts Python AST to concrete syntax
RDF4j-based serialization for Hydra RDF graphs.
Utilities for constructing generic program code ASTs, used for the serialization phase of source code generation.
A test case which serializes an AST expression to a string and compares it with the expected output
DSL interface providing set primitive operations.
Evaluation-level implementations of Set functions for the Hydra interpreter.
Primitive function which converts a bigfloat (arbitrary-precision decimal) to its string representation.
Primitive function which converts a bigint (arbitrary-precision integer) to its string representation.
Primitive function which converts a boolean to its string representation.
Primitive function which converts a float32 (32-bit floating-point) to its string representation.
Primitive function which converts a float64 (64-bit floating-point) to its string representation.
Primitive function which converts an int16 (16-bit signed integer) to its string representation.
Primitive function which converts an int32 (32-bit signed integer) to its string representation.
Primitive function which converts an int64 (64-bit signed integer) to its string representation.
Primitive function which converts an int8 (8-bit signed integer) to its string representation.
Primitive function which converts a string to its quoted string literal representation.
Converts a term to its string representation.
Primitive function which converts a uint16 (16-bit unsigned integer) to its string representation.
Primitive function which converts a uint32 (32-bit unsigned integer) to its string representation.
Primitive function which converts a uint64 (64-bit unsigned integer) to its string representation.
Primitive function which converts a uint8 (8-bit unsigned integer) to its string representation.
Returns the sign of a number.
Simple, one-way adapters for types and terms
A simple value binding
A test case which performs term simplification (beta reduction and optimization) and compares the result with the expected term
Computes the sine of an angle.
Creates a singleton list.
Creates a singleton list.
Creates a singleton set containing a single element.
Computes the hyperbolic sine.
Returns the number of entries.
Returns the number of elements in a set.
Sorts a list.
Utilities for sorting.
Sorts a list by a key function.
Splits a list at the first element not matching a predicate.
An import specification
A list of imports to exclude
A list of imports to include
Splits a string on a given delimiter.
Computes the square root.
A convenience class for stateless adapters; we use Hydra's Unit as the state type.
A convenience class for stateless coders; we use Hydra's Unit as the state type.
A do-notation statement
An atomic function as part of a query.
A comparison of two terms
An out-to-in traversal of an abstract edge
A projection from a record through one of its fields
Note: this is an approximation which ignores encoding
DSL interface providing string primitive operations.
Primitive function which converts a string to binary data.
Performs subtraction on two numbers.
A subspecification within an import/export
Import/export all
Import/export specific names
A test case which applies a type substitution to a type and compares the result.
Variable substitution in type and term expressions.
Returns the successor of an integer.
Any symbol
A nonterminal symbol
A simple table as in a CSV file, having an optional header row and any number of data rows
A type definition for a table, including column names and types
Term decoders for hydra.tabular
Term encoders for hydra.tabular
A tag for categorizing test cases
Returns all elements except the first.
Takes the first n elements.
Computes the tangent of an angle.
Computes the hyperbolic tangent.
This implementation of Tarjan's algorithm was originally based on GraphSCC by Iavor S.
An association of a named term (element) with a phantom type
A utility which instantiates a nonrecursive type with default values
A data term
A term annotated with metadata
A function application
An either value
A function term
A 'let' term, which binds variables to terms
A list
A literal value
A map of keys to values
An optional value
A pair (2-tuple)
A record term
A set of values
A System F type application term
A System F type abstraction term
An injection; an instance of a union type
A unit value; a term with no value
A variable reference
A wrapped term; an instance of a wrapper type (newtype)
A function which maps from a term to a particular immediate subterm
Access the body of an annotated term
Access the argument of an application term
Access the function of an application term
Access the term inside a union injection
Access the body of a lambda term
Access a specific binding in a let term by variable name
Access the body of a let term
Access an element of a list by index
Access a key in a map by index
Access a value in a map by index
Access the term inside a Just value
Access an element of a product (tuple) by index
Access a field of a record by field name
Access an element of a set by index
Access the term inside a sum variant
Access the term being applied to a type
Access the body of a type lambda term
Access a specific branch of a union elimination by field name
Access the default case of a union elimination
Access the term inside a wrapped term
A type together with a coder for mapping terms into arguments for primitive functions, and mapping computed results into terms
A term-level definition, including a name, a term, and the type scheme of the term
A predefined term rewriter for testing rewriteTerm
Replace all string literal 'foo' with 'bar'
Replace all Int32 literals with Int64 literals of the same value
Adapter framework for types and terms
A domain-specific language for constructing Hydra terms in Java.
A substitution of term variables for terms
The identifier of a term expression constructor
A simple test case with an input and an expected output
An alpha conversion test
A case conversion test
A deannotate term test
A deannotate type test
A delegated evaluation test
An eta expansion test
A term evaluation test
A flatten let terms test
A fold over term test
A free variables test
A hoist case statements test
A hoist all let bindings test (hoistAll=True, for Java)
A hoist polymorphic let bindings test
A hoist subterms test
A type inference test
A type inference failure test
A join types test (produce type constraints)
A JSON coder (round-trip) test using Flow-based coder
A JSON decode test using Either-based decoder
A JSON encode test using Either-based encoder
A JSON parser test
A JSON round-trip test using Either-based encoder/decoder
A JSON writer test
A lift lambda above let test
A normalize type variables test
A rewrite term test
A rewrite type test
An AST serialization test
A simplify term test
A type substitution test
A topological sort test
A topological sort bindings test
A topological sort with SCC detection test
A type checking test
A type checking failure test (currently unused)
A type reduction test
A type unification test
An unshadow variables test
An occur check test for type unification
One of a number of test case variants, together with metadata including a test name, an optional description, and optional tags
A codec for generating compiled test files from test groups into a target programming language
A collection of test cases with a name and optional description
Term decoders for hydra.testing
Term encoders for hydra.testing
Converts a map to a list of pairs.
Converts a set to a list of elements.
Converts a string to a list of character code points.
Converts a character to lowercase.
Converts a string to lowercase.
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
A test case which performs topological sort with strongly connected component detection and compares the result with expected components
A test case which performs topological sort on a directed graph and compares the result with either an expected sorted list or expected cycles
Term decoders for hydra.topology
Term encoders for hydra.topology
Converts a character to uppercase.
Converts a string to uppercase.
A container for logging and error information
The specification of a workflow which takes a schema specification, reads data from a directory, and writes data to another directory
Transposes a matrix (list of lists).
Specifies either a pre-order or post-order traversal
Post-order traversal
Pre-order traversal
An RDF triple defined by a subject, predicate, and object
A subject/predicate/object pattern
Truncates the decimal part.
An association of a term with a phantom type
A simple class for tuples (instances of product types) in Java.
A zero-tuple, i.e.
A one-tuple.
A two-tuple, i.e.
A three-tuple, i.e.
A four-tuple, i.e.
A five-tuple.
A six-tuple.
A seven-tuple.
An eight-tuple.
A nine-tuple.
A data type
A type expression
An annotated type
A type application
An application type
A context type
An either (sum) type
A universally quantified (polymorphic) type
A function type
A function type
An infix type
A list type
A list type
A literal type
A map type
An optional type
A pair (2-tuple) type
A parenthesized type
A record type
A set type
A tuple type
A union type with field names
The unit type
A type variable
A type variable or type name
A wrapped type (newtype)
A term applied to a type; a type application
A test case providing a term for which type checking is expected to fail.
A test case which performs type checking on a given term and compares the result with an expected annotated term and type
Any of a small number of built-in type classes
An assertion that two types can be unified into a single type
A typing environment used for type reconstruction (typeOf) over System F terms
A binding with its type signature
A type synonym declaration
A type-level definition, including a name and the type
A typed pattern
A System F type abstraction term
Phantom type variables for use in DSL signatures.
A test case which performs beta reduction on a type (reducing type applications) and compares the result with the expected type
A predefined type rewriter for testing rewriteType
Replace all String types with Int32 types
A domain-specific language for constructing Hydra types in Java.
A type expression together with free type variables occurring in the expression
A type signature
A type signature expression
A substitution of type variables for types
Metadata associated with a type variable, including typeclass constraints
The identifier of a type constructor
Term decoders for hydra.typing
Term encoders for hydra.typing
String representations of hydra.typing types
Primitive function which converts a uint16 (16-bit unsigned integer) to a bigint (arbitrary-precision integer).
Primitive function which converts a uint32 (32-bit unsigned integer) to a bigint (arbitrary-precision integer).
Primitive function which converts a uint64 (64-bit unsigned integer) to a bigint (arbitrary-precision integer).
Primitive function which converts a uint8 (8-bit unsigned integer) to a bigint (arbitrary-precision integer).
A ClassType which does not allow annotations
A Type which does not allow annotations
Utilities for type unification.
A test case which attempts to unify two types and compares the result.
Computes the union of two sets.
Computes the union of two sets.
Computes the union of multiple sets.
An empty record as a canonical unit value.
Joins a list of strings with newlines and appends a final newline.
A test case which renames shadowed variables in a term and compares the result with the expected term
An update record expression
Term decoders for hydra.util
Term encoders for hydra.util
Extraction and validation for hydra.util types
String representations of hydra.util types
Additional adapter utilities, above and beyond the generated ones.
Utilities for working with Haskell syntax trees
Java utilities for constructing Java syntax trees
Python utilities for constructing Python syntax trees
Utilities for validating property graphs against property graph schemas
A JSON value
A JSON array
A boolean value
JSON's null value
A numeric value
A JSON object as a set of key/value pairs
A string value
A value binding
A simple value binding
A type variable
A query variable
A test case which checks whether a type variable occurs in a type expression.
Term decoders for hydra.variants
Term encoders for hydra.variants
A vertex
A builder object for property graph vertices.
The label of a vertex.
The type of a vertex
A builder object for property graph vertex types.
A vertex together with any outgoing and/or incoming edges; a vertex object
Try a flow and use a fallback value if it fails.
Term decoders for hydra.workflow
Term encoders for hydra.workflow
A term wrapped in a type name
A type wrapped in a type name; a newtype
JSON serialization functions using the Hydra AST
A test case which writes a value to a string and compares it to the expected string
One of several classes of whitespace
A line break
A line break followed by indentation
Two line breaks
No whitespace
A single space
Zips two lists into pairs.
Zips two lists with a function.