hydra namespace

Subpackages

• hydra.decode namespace
  • Subpackages
    • hydra.decode.error namespace
      • Submodules
    • hydra.decode.json namespace
      • Submodules
    • hydra.decode.yaml namespace
      • Submodules
  • Submodules
    • hydra.decode.ast module
      • associativity()
      • block_style()
      • bracket_expr()
      • brackets()
      • expr()
      • indent_style()
      • indented_expression()
      • op()
      • op_expr()
      • padding()
      • precedence()
      • seq_expr()
      • symbol()
      • ws()
    • hydra.decode.coders module
      • case_conventions()
      • coder_direction()
      • language_feature()
      • language_name()
      • traversal_order()
    • hydra.decode.core module
      • annotated_term()
      • annotated_type()
      • application()
      • application_type()
      • binding()
      • case_alternative()
      • case_statement()
      • either_type()
      • field()
      • field_type()
      • float_type()
      • float_value()
      • forall_type()
      • function_type()
      • injection()
      • integer_type()
      • integer_value()
      • lambda_()
      • let()
      • literal()
      • literal_type()
      • map_type()
      • name()
      • pair_type()
      • projection()
      • record()
      • term()
      • type()
      • type_application_term()
      • type_class_constraint()
      • type_lambda()
      • type_scheme()
      • type_variable_constraints()
      • wrapped_term()
    • hydra.decode.docs module
      • doc_segment()
    • hydra.decode.errors module
      • decoding_error()
      • empty_list_error()
      • error()
      • extraction_error()
      • inference_error()
      • multiple_bindings_error()
      • multiple_fields_error()
      • no_matching_field_error()
      • no_such_binding_error()
      • no_such_primitive_error()
      • not_enough_cases_error()
      • other_error()
      • other_inference_error()
      • other_resolution_error()
      • resolution_error()
      • unexpected_shape_error()
      • unification_error()
      • unification_inference_error()
    • hydra.decode.file module
      • file_extension()
      • file_path()
      • file_status()
      • file_type()
    • hydra.decode.packaging module
      • definition()
      • definition_reference()
      • dependency_scope()
      • entity_metadata()
      • entity_reference()
      • lifecycle_info()
      • module()
      • module_dependency()
      • module_name()
      • package()
      • package_dependency()
      • package_name()
      • primitive_definition()
      • term_definition()
      • type_definition()
      • version()
      • version_range()
      • version_specifier()
    • hydra.decode.parsing module
      • parse_error()
      • parse_result()
      • parse_success()
    • hydra.decode.paths module
      • subterm_attribute()
      • subterm_edge()
      • subterm_graph()
      • subterm_link()
      • subterm_node()
      • subterm_path()
      • subterm_property()
      • subterm_step()
      • subtype_attribute()
      • subtype_edge()
      • subtype_graph()
      • subtype_link()
      • subtype_node()
      • subtype_path()
      • subtype_property()
      • subtype_step()
      • term_attribute()
      • type_attribute()
    • hydra.decode.query module
      • comparison_constraint()
      • edge()
      • graph_pattern()
      • node()
      • path()
      • path_equation()
      • pattern()
      • pattern_implication()
      • query()
      • range_()
      • regex_quantifier()
      • regex_sequence()
      • step()
      • triple_pattern()
      • variable()
    • hydra.decode.regex module
      • alternation()
      • atom()
      • character_class()
      • character_range()
      • class_item()
      • quantified()
      • quantifier()
      • quantifier_range()
      • regex()
      • regex_sequence()
    • hydra.decode.relational module
      • column_name()
      • column_schema()
      • foreign_key()
      • primary_key()
      • relation()
      • relation_name()
      • relation_schema()
      • relationship()
      • row()
    • hydra.decode.system module
      • command()
      • environment_variable()
      • process_result()
      • status_code()
    • hydra.decode.tabular module
      • column_type()
      • data_row()
      • header_row()
      • table()
      • table_type()
    • hydra.decode.testing module
      • tag()
    • hydra.decode.time module
      • timespec()
    • hydra.decode.topology module
      • graph()
      • tarjan_state()
      • vertex()
    • hydra.decode.typed module
      • typed_binding()
      • typed_name()
      • typed_term()
      • typed_term_definition()
    • hydra.decode.typing module
      • function_structure()
      • inference_context()
      • inference_result()
      • parameter()
      • result()
      • term_signature()
      • term_subst()
      • type_class()
      • type_constraint()
      • type_parameter()
      • type_subst()
    • hydra.decode.util module
      • case_convention()
      • comparison()
      • module_names()
      • precision()
      • qualified_name()
    • hydra.decode.validation module
      • validation_profile()
      • validation_result()
    • hydra.decode.variants module
      • literal_variant()
      • term_variant()
      • type_variant()
• hydra.dsl namespace
  • Subpackages
    • hydra.dsl.error namespace
      • Submodules
    • hydra.dsl.extract namespace
      • Submodules
    • hydra.dsl.json namespace
      • Subpackages
      • Submodules
    • hydra.dsl.lib namespace
      • Submodules
    • hydra.dsl.print namespace
      • Submodules
    • hydra.dsl.test namespace
      • Submodules
    • hydra.dsl.yaml namespace
      • Submodules
  • Submodules
    • hydra.dsl.analysis module
      • add_names_to_module_names()
      • analyze_function_term()
      • analyze_function_term_with()
      • analyze_function_term_with_finish()
      • analyze_function_term_with_gather()
      • definition_dependency_module_names()
      • dependency_module_names()
      • gather_applications()
      • gather_args()
      • gather_args_with_type_apps()
      • is_self_tail_recursive()
      • is_simple_assignment()
      • is_tail_recursive_in_tail_position()
      • module_contains_binary_literals()
      • module_contains_decimal_literals()
      • module_dependency_module_names()
      • module_names_for_definitions()
    • hydra.dsl.annotations module
      • aggregate_annotations()
      • comments_from_binding()
      • comments_from_field_type()
      • get_annotation_map()
      • get_description()
      • get_term_annotation()
      • get_term_description()
      • get_type()
      • get_type_annotation()
      • get_type_classes()
      • get_type_description()
      • has_description()
      • has_type_description()
      • is_native_type()
      • normalize_term_annotations()
      • normalize_type_annotations()
      • set_annotation()
      • set_description()
      • set_term_annotation()
      • set_term_description()
      • set_type()
      • set_type_annotation()
      • set_type_classes()
      • set_type_description()
      • term_annotation_internal()
      • type_annotation_internal()
      • wrap_annotation_map()
    • hydra.dsl.arity module
      • primitive_arity()
      • term_arity()
      • type_arity()
      • type_scheme_arity()
      • uncurry_type()
    • hydra.dsl.ast module
      • block_style()
      • block_style_indent()
      • block_style_newline_after_content()
      • block_style_newline_before_content()
      • block_style_with_indent()
      • block_style_with_newline_after_content()
      • block_style_with_newline_before_content()
      • bracket_expr()
      • bracket_expr_brackets()
      • bracket_expr_enclosed()
      • bracket_expr_style()
      • bracket_expr_with_brackets()
      • bracket_expr_with_enclosed()
      • bracket_expr_with_style()
      • brackets()
      • brackets_close()
      • brackets_open()
      • brackets_with_close()
      • brackets_with_open()
      • expr_brackets()
      • expr_const()
      • expr_indent()
      • expr_op()
      • expr_seq()
      • indent_style_all_lines()
      • indent_style_subsequent_lines()
      • indented_expression()
      • indented_expression_expr()
      • indented_expression_style()
      • indented_expression_with_expr()
      • indented_expression_with_style()
      • op()
      • op_associativity()
      • op_expr()
      • op_expr_lhs()
      • op_expr_op()
      • op_expr_rhs()
      • op_expr_with_lhs()
      • op_expr_with_op()
      • op_expr_with_rhs()
      • op_padding()
      • op_precedence()
      • op_symbol()
      • op_with_associativity()
      • op_with_padding()
      • op_with_precedence()
      • op_with_symbol()
      • padding()
      • padding_left()
      • padding_right()
      • padding_with_left()
      • padding_with_right()
      • precedence()
      • seq_expr()
      • seq_expr_elements()
      • seq_expr_op()
      • seq_expr_with_elements()
      • seq_expr_with_op()
      • symbol()
      • un_precedence()
      • un_symbol()
      • ws_break_and_indent()
    • hydra.dsl.checking module
      • all_equal()
      • apply_type_arguments_to_type()
      • check_for_unbound_type_variables()
      • check_same_type()
      • check_type_subst()
      • contains_in_scope_type_vars()
      • normalize_type_free_vars()
      • to_f_context()
      • type_lists_effectively_equal()
      • type_of()
      • type_of_annotated_term()
      • type_of_application()
      • type_of_case_statement()
      • type_of_either()
      • type_of_injection()
      • type_of_lambda()
      • type_of_let()
      • type_of_list()
      • type_of_literal()
      • type_of_map()
      • type_of_maybe()
      • type_of_pair()
      • type_of_primitive()
      • type_of_projection()
      • type_of_record()
      • type_of_set()
      • type_of_term()
      • type_of_type_application()
      • type_of_type_lambda()
      • type_of_unit()
      • type_of_unwrap()
      • type_of_variable()
      • type_of_wrapped_term()
      • types_all_effectively_equal()
      • types_effectively_equal()
    • hydra.dsl.coders module
      • adapter()
      • adapter_coder()
      • adapter_context()
      • adapter_context_adapters()
      • adapter_context_graph()
      • adapter_context_language()
      • adapter_context_with_adapters()
      • adapter_context_with_graph()
      • adapter_context_with_language()
      • adapter_is_lossy()
      • adapter_source()
      • adapter_target()
      • adapter_with_coder()
      • adapter_with_is_lossy()
      • adapter_with_source()
      • adapter_with_target()
      • bicoder()
      • bicoder_decode()
      • bicoder_encode()
      • bicoder_with_decode()
      • bicoder_with_encode()
      • case_conventions()
      • case_conventions_constant()
      • case_conventions_directory()
      • case_conventions_enum_value()
      • case_conventions_field()
      • case_conventions_file()
      • case_conventions_module()
      • case_conventions_term()
      • case_conventions_term_variable()
      • case_conventions_type()
      • case_conventions_type_variable()
      • case_conventions_with_constant()
      • case_conventions_with_directory()
      • case_conventions_with_enum_value()
      • case_conventions_with_field()
      • case_conventions_with_file()
      • case_conventions_with_module()
      • case_conventions_with_term()
      • case_conventions_with_term_variable()
      • case_conventions_with_type()
      • case_conventions_with_type_variable()
      • coder()
      • coder_decode()
      • coder_encode()
      • coder_with_decode()
      • coder_with_encode()
      • decode_adapter()
      • decode_bicoder()
      • decode_coder()
      • encode_adapter()
      • encode_bicoder()
      • encode_coder()
      • language()
      • language_case_conventions()
      • language_constraints()
      • language_constraints2()
      • language_constraints_float_types()
      • language_constraints_integer_types()
      • language_constraints_literal_variants()
      • language_constraints_term_variants()
      • language_constraints_type_variants()
      • language_constraints_types()
      • language_constraints_with_float_types()
      • language_constraints_with_integer_types()
      • language_constraints_with_literal_variants()
      • language_constraints_with_term_variants()
      • language_constraints_with_type_variants()
      • language_constraints_with_types()
      • language_default_file_extension()
      • language_name()
      • language_name2()
      • language_supported_features()
      • language_with_case_conventions()
      • language_with_constraints()
      • language_with_default_file_extension()
      • language_with_name()
      • language_with_supported_features()
      • un_language_name()
    • hydra.dsl.constants module
    • hydra.dsl.core module
      • annotated_term()
      • annotated_term_annotation()
      • annotated_term_body()
      • annotated_term_with_annotation()
      • annotated_term_with_body()
      • annotated_type()
      • annotated_type_annotation()
      • annotated_type_body()
      • annotated_type_with_annotation()
      • annotated_type_with_body()
      • application()
      • application_argument()
      • application_function()
      • application_type()
      • application_type_argument()
      • application_type_function()
      • application_type_with_argument()
      • application_type_with_function()
      • application_with_argument()
      • application_with_function()
      • binding()
      • binding_name()
      • binding_term()
      • binding_type_scheme()
      • binding_with_name()
      • binding_with_term()
      • binding_with_type_scheme()
      • case_alternative()
      • case_alternative_handler()
      • case_alternative_name()
      • case_alternative_with_handler()
      • case_alternative_with_name()
      • case_statement()
      • case_statement_cases()
      • case_statement_default()
      • case_statement_type_name()
      • case_statement_with_cases()
      • case_statement_with_default()
      • case_statement_with_type_name()
      • either_type()
      • either_type_left()
      • either_type_right()
      • either_type_with_left()
      • either_type_with_right()
      • field()
      • field_name()
      • field_term()
      • field_type()
      • field_type_name()
      • field_type_type()
      • field_type_with_name()
      • field_type_with_type()
      • field_with_name()
      • field_with_term()
      • float_value_float32()
      • float_value_float64()
      • forall_type()
      • forall_type_body()
      • forall_type_parameter()
      • forall_type_with_body()
      • forall_type_with_parameter()
      • function_type()
      • function_type_codomain()
      • function_type_domain()
      • function_type_with_codomain()
      • function_type_with_domain()
      • injection()
      • injection_field()
      • injection_type_name()
      • injection_with_field()
      • injection_with_type_name()
      • integer_value_bigint()
      • integer_value_int16()
      • integer_value_int32()
      • integer_value_int64()
      • integer_value_int8()
      • integer_value_uint16()
      • integer_value_uint32()
      • integer_value_uint64()
      • integer_value_uint8()
      • lambda_()
      • lambda_body()
      • lambda_domain()
      • lambda_parameter()
      • lambda_with_body()
      • lambda_with_domain()
      • lambda_with_parameter()
      • let()
      • let_bindings()
      • let_body()
      • let_with_bindings()
      • let_with_body()
      • literal_binary()
      • literal_boolean()
      • literal_decimal()
      • literal_float()
      • literal_integer()
      • literal_string()
      • literal_type_float()
      • literal_type_integer()
      • map_type()
      • map_type_keys()
      • map_type_values()
      • map_type_with_keys()
      • map_type_with_values()
      • name()
      • pair_type()
      • pair_type_first()
      • pair_type_second()
      • pair_type_with_first()
      • pair_type_with_second()
      • projection()
      • projection_field_name()
      • projection_type_name()
      • projection_with_field_name()
      • projection_with_type_name()
      • record()
      • record_fields()
      • record_type_name()
      • record_with_fields()
      • record_with_type_name()
      • term_annotated()
      • term_application()
      • term_cases()
      • term_either()
      • term_inject()
      • term_lambda()
      • term_let()
      • term_list()
      • term_literal()
      • term_map()
      • term_optional()
      • term_pair()
      • term_project()
      • term_record()
      • term_set()
      • term_type_application()
      • term_type_lambda()
      • term_unwrap()
      • term_variable()
      • term_wrap()
      • type_annotated()
      • type_application()
      • type_application_term()
      • type_application_term_body()
      • type_application_term_type()
      • type_application_term_with_body()
      • type_application_term_with_type()
      • type_class_constraint_simple()
      • type_effect()
      • type_either()
      • type_forall()
      • type_function()
      • type_lambda()
      • type_lambda_body()
      • type_lambda_parameter()
      • type_lambda_with_body()
      • type_lambda_with_parameter()
      • type_list()
      • type_literal()
      • type_map()
      • type_optional()
      • type_pair()
      • type_record()
      • type_scheme()
      • type_scheme_body()
      • type_scheme_constraints()
      • type_scheme_variables()
      • type_scheme_with_body()
      • type_scheme_with_constraints()
      • type_scheme_with_variables()
      • type_set()
      • type_union()
      • type_variable()
      • type_variable_constraints()
      • type_variable_constraints_classes()
      • type_variable_constraints_with_classes()
      • type_wrap()
      • un_name()
      • wrapped_term()
      • wrapped_term_body()
      • wrapped_term_type_name()
      • wrapped_term_with_body()
      • wrapped_term_with_type_name()
    • hydra.dsl.dependencies module
      • definitions_with_dependencies()
      • flatten_let_terms()
      • inline_type()
      • is_lambda()
      • lift_lambda_above_let()
      • prune_let()
      • replace_typedefs()
      • simplify_term()
      • term_dependency_names()
      • to_short_names()
      • topological_sort_binding_map()
      • topological_sort_bindings()
      • topological_sort_type_definitions()
      • type_dependency_names()
      • type_names_in_type()
    • hydra.dsl.docs module
      • doc_segment_ref()
      • doc_segment_text()
    • hydra.dsl.environment module
      • definition_as_type_application_term()
      • graph_as_let()
      • graph_as_term()
      • graph_as_types()
      • partition_definitions()
      • reorder_defs()
      • schema_graph_to_typing_environment()
      • term_as_bindings()
      • types_to_definitions()
      • with_lambda_context()
      • with_let_context()
      • with_type_lambda_context()
    • hydra.dsl.errors module
      • decoding_error()
      • error_checking()
      • error_decoding()
      • error_duplicate_binding()
      • error_duplicate_field()
      • error_extraction()
      • error_inference()
      • error_invalid_literal()
      • error_other()
      • error_resolution()
      • error_undefined_field()
      • error_undefined_term_variable()
      • error_unexpected_term_variant()
      • error_unexpected_type_variant()
      • error_unification()
      • error_untyped_term_variable()
      • extraction_error_empty_list()
      • extraction_error_multiple_bindings()
      • extraction_error_multiple_fields()
      • extraction_error_no_matching_field()
      • extraction_error_no_such_binding()
      • extraction_error_not_enough_cases()
      • extraction_error_unexpected_shape()
      • inference_error_checking()
      • inference_error_other()
      • inference_error_unification()
      • multiple_bindings_error()
      • multiple_bindings_error_name()
      • multiple_bindings_error_with_name()
      • multiple_fields_error()
      • multiple_fields_error_field_name()
      • multiple_fields_error_with_field_name()
      • no_matching_field_error()
      • no_matching_field_error_field_name()
      • no_matching_field_error_with_field_name()
      • no_such_binding_error()
      • no_such_binding_error_name()
      • no_such_binding_error_with_name()
      • no_such_primitive_error()
      • no_such_primitive_error_name()
      • no_such_primitive_error_with_name()
      • other_error()
      • other_inference_error()
      • other_inference_error_message()
      • other_inference_error_path()
      • other_inference_error_with_message()
      • other_inference_error_with_path()
      • other_resolution_error()
      • resolution_error_no_matching_field()
      • resolution_error_no_such_binding()
      • resolution_error_no_such_primitive()
      • resolution_error_other()
      • resolution_error_unexpected_shape()
      • un_decoding_error()
      • un_other_error()
      • un_other_resolution_error()
      • unexpected_shape_error()
      • unexpected_shape_error_actual()
      • unexpected_shape_error_expected()
      • unexpected_shape_error_with_actual()
      • unexpected_shape_error_with_expected()
      • unification_error()
      • unification_error_left_type()
      • unification_error_message()
      • unification_error_right_type()
      • unification_error_with_left_type()
      • unification_error_with_message()
      • unification_error_with_right_type()
      • unification_inference_error()
      • unification_inference_error_cause()
      • unification_inference_error_path()
      • unification_inference_error_with_cause()
      • unification_inference_error_with_path()
    • hydra.dsl.file module
      • file_extension()
      • file_path()
      • file_status()
      • file_status_access_time()
      • file_status_file_type()
      • file_status_modification_time()
      • file_status_size()
      • file_status_status_change_time()
      • file_status_with_access_time()
      • file_status_with_file_type()
      • file_status_with_modification_time()
      • file_status_with_size()
      • file_status_with_status_change_time()
      • un_file_extension()
      • un_file_path()
    • hydra.dsl.formatting module
      • capitalize()
      • convert_case()
      • convert_case_camel_or_underscore_to_lower_snake()
      • convert_case_camel_to_lower_snake()
      • convert_case_camel_to_upper_snake()
      • convert_case_pascal_to_upper_snake()
      • decapitalize()
      • escape_with_underscore()
      • indent_lines()
      • java_style_comment()
      • lines()
      • map_first_letter()
      • non_alnum_to_underscores()
      • normalize_comment()
      • sanitize_with_underscores()
      • show_list()
      • strip_leading_and_trailing_whitespace()
      • unlines()
      • with_character_aliases()
      • wrap_line()
    • hydra.dsl.graph module
      • decode_term_coder()
      • encode_term_coder()
      • graph()
      • graph_bound_terms()
      • graph_bound_types()
      • graph_class_constraints()
      • graph_lambda_variables()
      • graph_metadata()
      • graph_primitives()
      • graph_schema_types()
      • graph_type_variables()
      • graph_with_bound_terms()
      • graph_with_bound_types()
      • graph_with_class_constraints()
      • graph_with_lambda_variables()
      • graph_with_metadata()
      • graph_with_primitives()
      • graph_with_schema_types()
      • graph_with_type_variables()
      • library()
      • library_name()
      • library_prefix()
      • library_primitives()
      • library_with_name()
      • library_with_prefix()
      • library_with_primitives()
      • primitive()
      • primitive_definition()
      • primitive_implementation()
      • primitive_with_definition()
      • primitive_with_implementation()
      • term_coder()
      • term_coder_decode()
      • term_coder_encode()
      • term_coder_type()
      • term_coder_with_decode()
      • term_coder_with_encode()
      • term_coder_with_type()
    • hydra.dsl.lexical module
      • build_graph()
      • choose_unique_name()
      • dereference_schema_type()
      • dereference_variable()
      • elements_to_graph()
      • fields_of()
      • get_field()
      • graph_to_bindings()
      • graph_with_primitives()
      • lookup_binding()
      • lookup_primitive()
      • lookup_term()
      • match_enum()
      • match_record()
      • match_union()
      • match_unit_field()
      • require_binding()
      • require_primitive()
      • require_primitive_type()
      • require_term()
      • resolve_term()
      • strip_and_dereference_term()
      • strip_and_dereference_term_either()
    • hydra.dsl.names module
      • choose_unique_label()
      • compact_name()
      • derived_binding_name()
      • derived_definition_name()
      • derived_module_name()
      • fresh_name()
      • fresh_names()
      • local_name_of()
      • module_name_of()
      • module_name_to_file_path()
      • name_to_file_path()
      • normal_type_variable()
      • push_subterm_step()
      • qname()
      • qualify_name()
      • restore_trace()
      • unqualify_name()
    • hydra.dsl.packaging module
      • definition_primitive()
      • definition_reference_primitive()
      • definition_reference_term()
      • definition_reference_type()
      • definition_term()
      • definition_type()
      • entity_metadata()
      • entity_metadata_comments()
      • entity_metadata_description()
      • entity_metadata_lifecycle()
      • entity_metadata_see_also()
      • entity_metadata_with_comments()
      • entity_metadata_with_description()
      • entity_metadata_with_lifecycle()
      • entity_metadata_with_see_also()
      • entity_reference_definition()
      • entity_reference_module()
      • entity_reference_package()
      • entity_reference_term_expr()
      • entity_reference_type_expr()
      • lifecycle_info()
      • lifecycle_info_available_since()
      • lifecycle_info_deprecated_since()
      • lifecycle_info_with_available_since()
      • lifecycle_info_with_deprecated_since()
      • module()
      • module_definitions()
      • module_dependencies()
      • module_dependency()
      • module_dependency_module()
      • module_dependency_package()
      • module_dependency_with_module()
      • module_dependency_with_package()
      • module_metadata()
      • module_name()
      • module_name2()
      • module_with_definitions()
      • module_with_dependencies()
      • module_with_metadata()
      • module_with_name()
      • package()
      • package_dependencies()
      • package_dependency()
      • package_dependency_name()
      • package_dependency_scope()
      • package_dependency_version()
      • package_dependency_with_name()
      • package_dependency_with_scope()
      • package_dependency_with_version()
      • package_metadata()
      • package_modules()
      • package_name()
      • package_name2()
      • package_with_dependencies()
      • package_with_metadata()
      • package_with_modules()
      • package_with_name()
      • primitive_definition()
      • primitive_definition_default_implementation()
      • primitive_definition_is_pure()
      • primitive_definition_is_total()
      • primitive_definition_metadata()
      • primitive_definition_name()
      • primitive_definition_signature()
      • primitive_definition_with_default_implementation()
      • primitive_definition_with_is_pure()
      • primitive_definition_with_is_total()
      • primitive_definition_with_metadata()
      • primitive_definition_with_name()
      • primitive_definition_with_signature()
      • term_definition()
      • term_definition_body()
      • term_definition_metadata()
      • term_definition_name()
      • term_definition_signature()
      • term_definition_with_body()
      • term_definition_with_metadata()
      • term_definition_with_name()
      • term_definition_with_signature()
      • type_definition()
      • type_definition_body()
      • type_definition_metadata()
      • type_definition_name()
      • type_definition_with_body()
      • type_definition_with_metadata()
      • type_definition_with_name()
      • un_module_name()
      • un_package_name()
      • un_version()
      • version()
      • version_range()
      • version_range_lower_inclusive()
      • version_range_upper_exclusive()
      • version_range_with_lower_inclusive()
      • version_range_with_upper_exclusive()
      • version_specifier_at_least()
      • version_specifier_exact()
      • version_specifier_range()
    • hydra.dsl.parsing module
      • decode_parse_result()
      • decode_parse_success()
      • decode_parser()
      • encode_parse_result()
      • encode_parse_success()
      • encode_parser()
      • parse_error()
      • parse_error_message()
      • parse_error_remainder()
      • parse_error_with_message()
      • parse_error_with_remainder()
      • parse_result_failure()
      • parse_result_success()
      • parse_success()
      • parse_success_remainder()
      • parse_success_value()
      • parse_success_with_remainder()
      • parse_success_with_value()
      • parser()
      • un_parser()
    • hydra.dsl.paths module
      • subterm_attribute()
      • subterm_attribute_path()
      • subterm_attribute_target()
      • subterm_attribute_with_path()
      • subterm_attribute_with_target()
      • subterm_edge()
      • subterm_edge_path()
      • subterm_edge_target()
      • subterm_edge_with_path()
      • subterm_edge_with_target()
      • subterm_graph()
      • subterm_graph_nodes()
      • subterm_graph_with_nodes()
      • subterm_link_attribute()
      • subterm_link_edge()
      • subterm_link_property()
      • subterm_node()
      • subterm_node_links()
      • subterm_node_name()
      • subterm_node_type()
      • subterm_node_with_links()
      • subterm_node_with_name()
      • subterm_node_with_type()
      • subterm_path()
      • subterm_property()
      • subterm_property_path()
      • subterm_property_target()
      • subterm_property_with_path()
      • subterm_property_with_target()
      • subterm_step_cases_case()
      • subterm_step_inject_field()
      • subterm_step_let_binding()
      • subterm_step_list_element()
      • subterm_step_map_key()
      • subterm_step_map_value()
      • subterm_step_record_field()
      • subterm_step_set_element()
      • subtype_attribute()
      • subtype_attribute_path()
      • subtype_attribute_target()
      • subtype_attribute_with_path()
      • subtype_attribute_with_target()
      • subtype_edge()
      • subtype_edge_path()
      • subtype_edge_target()
      • subtype_edge_with_path()
      • subtype_edge_with_target()
      • subtype_graph()
      • subtype_graph_nodes()
      • subtype_graph_with_nodes()
      • subtype_link_attribute()
      • subtype_link_edge()
      • subtype_link_property()
      • subtype_node()
      • subtype_node_links()
      • subtype_node_name()
      • subtype_node_with_links()
      • subtype_node_with_name()
      • subtype_path()
      • subtype_property()
      • subtype_property_path()
      • subtype_property_target()
      • subtype_property_with_path()
      • subtype_property_with_target()
      • subtype_step_record_field()
      • subtype_step_union_field()
      • term_attribute_cases_type_name()
      • term_attribute_inject_type_name()
      • term_attribute_lambda_domain_given()
      • term_attribute_lambda_parameter()
      • term_attribute_let_binding_type_scheme_given()
      • term_attribute_project_field_name()
      • term_attribute_project_type_name()
      • term_attribute_record_type_name()
      • term_attribute_type_application_type()
      • term_attribute_type_lambda_parameter()
      • term_attribute_wrap_type_name()
      • type_attribute_annotated_annotation()
      • type_attribute_forall_parameter()
      • un_subterm_path()
      • un_subtype_path()
    • hydra.dsl.predicates module
      • is_complex_binding()
      • is_complex_term()
      • is_complex_variable()
      • is_encoded_term()
      • is_encoded_type()
      • is_enum_row_type()
      • is_enum_type()
      • is_nominal_type()
      • is_serializable()
      • is_serializable_by_name()
      • is_serializable_type()
      • is_trivial_term()
      • is_type()
      • is_unit_term()
      • is_unit_type()
      • type_dependencies()
    • hydra.dsl.query module
      • edge()
      • edge_in()
      • edge_out()
      • edge_type()
      • edge_with_in()
      • edge_with_out()
      • edge_with_type()
      • graph_pattern()
      • graph_pattern_graph()
      • graph_pattern_patterns()
      • graph_pattern_with_graph()
      • graph_pattern_with_patterns()
      • node_term()
      • node_variable()
      • path_equation()
      • path_equation_left()
      • path_equation_right()
      • path_equation_with_left()
      • path_equation_with_right()
      • path_inverse()
      • path_regex()
      • path_step()
      • pattern_conjunction()
      • pattern_disjunction()
      • pattern_graph()
      • pattern_implication()
      • pattern_implication_antecedent()
      • pattern_implication_consequent()
      • pattern_implication_with_antecedent()
      • pattern_implication_with_consequent()
      • pattern_negation()
      • pattern_triple()
      • query()
      • query_patterns()
      • query_variables()
      • query_with_patterns()
      • query_with_variables()
      • range_()
      • range_max()
      • range_min()
      • range_with_max()
      • range_with_min()
      • regex_quantifier_at_least()
      • regex_quantifier_exactly()
      • regex_quantifier_range()
      • regex_sequence()
      • regex_sequence_path()
      • regex_sequence_quantifier()
      • regex_sequence_with_path()
      • regex_sequence_with_quantifier()
      • step_compare()
      • step_edge()
      • step_project()
      • triple_pattern()
      • triple_pattern_object()
      • triple_pattern_predicate()
      • triple_pattern_subject()
      • triple_pattern_with_object()
      • triple_pattern_with_predicate()
      • triple_pattern_with_subject()
      • un_variable()
      • variable()
    • hydra.dsl.reduction module
      • alpha_convert()
      • beta_reduce_type()
      • contract_term()
      • eta_expand_term()
      • eta_expand_typed_term()
      • eta_expansion_arity()
      • eta_reduce_term()
      • reduce_term()
      • term_is_closed()
      • term_is_value()
    • hydra.dsl.refs module
      • decode_ref()
      • encode_list()
      • encode_map()
      • encode_optional()
      • encode_pair()
      • encode_ref()
      • encode_set()
      • show_ref()
    • hydra.dsl.regex module
      • atom_class()
      • atom_group()
      • atom_literal()
      • character_class()
      • character_class_items()
      • character_class_negated()
      • character_class_with_items()
      • character_class_with_negated()
      • character_range()
      • character_range_from()
      • character_range_to()
      • character_range_with_from()
      • character_range_with_to()
      • class_item_character()
      • class_item_range()
      • quantified()
      • quantified_atom()
      • quantified_quantifier()
      • quantified_with_atom()
      • quantified_with_quantifier()
      • quantifier_at_least()
      • quantifier_exactly()
      • quantifier_range()
      • quantifier_range2()
      • quantifier_range_max()
      • quantifier_range_min()
      • quantifier_range_with_max()
      • quantifier_range_with_min()
    • hydra.dsl.relational module
      • column_name()
      • column_schema()
      • column_schema_domain()
      • column_schema_name()
      • column_schema_with_domain()
      • column_schema_with_name()
      • decode_column_schema()
      • decode_relation()
      • decode_relation_schema()
      • decode_relationship()
      • decode_row()
      • encode_column_schema()
      • encode_relation()
      • encode_relation_schema()
      • encode_relationship()
      • encode_row()
      • foreign_key()
      • foreign_key_foreign_relation()
      • foreign_key_keys()
      • foreign_key_with_foreign_relation()
      • foreign_key_with_keys()
      • primary_key()
      • relation()
      • relation_name()
      • relation_schema()
      • relation_schema_columns()
      • relation_schema_foreign_keys()
      • relation_schema_name()
      • relation_schema_primary_keys()
      • relation_schema_with_columns()
      • relation_schema_with_foreign_keys()
      • relation_schema_with_name()
      • relation_schema_with_primary_keys()
      • relationship()
      • row()
      • un_column_name()
      • un_primary_key()
      • un_relation()
      • un_relation_name()
      • un_relationship()
      • un_row()
    • hydra.dsl.resolution module
      • dereference_type()
      • f_type_is_polymorphic()
      • field_map()
      • field_type_map()
      • field_types()
      • find_field_type()
      • fully_strip_and_normalize_type()
      • fully_strip_type()
      • instantiate_type()
      • instantiate_type_scheme()
      • map_key_resolves_to_string()
      • nominal_application()
      • require_record_type()
      • require_row_type()
      • require_schema_type()
      • require_type()
      • require_union_field()
      • require_union_type()
      • resolve_base_type()
      • resolve_type()
      • type_to_type_scheme()
    • hydra.dsl.rewriting module
      • apply_inside_type_lambdas_and_annotations()
      • fold_over_term()
      • fold_over_type()
      • fold_term_with_graph_and_path()
      • map_beneath_type_annotations()
      • rewrite_and_fold_term()
      • rewrite_and_fold_term_with_graph()
      • rewrite_and_fold_term_with_graph_and_path()
      • rewrite_and_fold_term_with_path()
      • rewrite_term()
      • rewrite_term_m()
      • rewrite_term_with_context()
      • rewrite_term_with_context_m()
      • rewrite_term_with_graph()
      • rewrite_type()
      • rewrite_type_m()
      • subterms()
      • subterms_with_steps()
      • subtypes()
      • subtypes_with_steps()
      • wrap_term_to_record()
      • wrap_type_to_record()
    • hydra.dsl.scoping module
      • extend_graph_for_lambda()
      • extend_graph_for_let()
      • extend_graph_for_type_lambda()
      • extend_graph_with_bindings()
      • f_type_to_type_scheme()
      • term_signature_to_type_scheme()
      • type_scheme_to_f_type()
      • type_scheme_to_term_signature()
    • hydra.dsl.serialization module
      • angle_braces_list()
      • braces_list_adaptive()
      • bracket_list()
      • bracket_list_adaptive()
      • brackets()
      • choose_layout()
      • comma_sep()
      • comma_sep_adaptive()
      • cst()
      • curly_block()
      • curly_braces_list()
      • custom_indent()
      • custom_indent_block()
      • dot_sep()
      • double_newline_sep()
      • expression_length()
      • ifx()
      • indent()
      • indent_block()
      • indent_subsequent_lines()
      • infix_ws()
      • infix_ws_list()
      • newline_sep()
      • no_sep()
      • num()
      • op()
      • or_op()
      • or_sep()
      • paren_list()
      • paren_list_adaptive()
      • parens()
      • parenthesize()
      • prefix()
      • print_expr()
      • semicolon_sep()
      • sep()
      • space_sep()
      • space_sep_adaptive()
      • structural_sep()
      • structural_space_sep()
      • suffix()
      • sym()
      • symbol_sep()
      • tab_indent()
      • tab_indent_double_space()
      • tab_indent_single_space()
      • unsupported_type()
      • unsupported_variant()
      • with_comma()
      • with_semi()
    • hydra.dsl.sorting module
      • adjacency_list_to_map()
      • adjacency_lists_to_graph()
      • create_ordering_isomorphism()
      • find_reachable_nodes()
      • pop_stack_until()
      • propagate_tags()
      • strong_connect()
      • strongly_connected_components()
      • topological_sort()
      • topological_sort_components()
      • topological_sort_nodes()
    • hydra.dsl.strip module
      • deannotate_and_detype_term()
      • deannotate_term()
      • deannotate_type()
      • deannotate_type_parameters()
      • deannotate_type_recursive()
      • deannotate_type_scheme_recursive()
      • detype_term()
      • remove_term_annotations()
      • remove_type_annotations()
      • remove_type_annotations_from_term()
      • remove_types_from_term()
      • strip_type_lambdas()
    • hydra.dsl.system module
      • command()
      • command_arguments()
      • command_environment()
      • command_program()
      • command_with_arguments()
      • command_with_environment()
      • command_with_program()
      • command_with_working_directory()
      • command_working_directory()
      • environment_variable()
      • process_result()
      • process_result_exit_code()
      • process_result_stderr()
      • process_result_stdout()
      • process_result_with_exit_code()
      • process_result_with_stderr()
      • process_result_with_stdout()
      • status_code()
      • un_environment_variable()
      • un_status_code()
    • hydra.dsl.tabular module
      • column_type()
      • column_type_name()
      • column_type_type()
      • column_type_with_name()
      • column_type_with_type()
      • data_row()
      • decode_data_row()
      • decode_table()
      • encode_data_row()
      • encode_table()
      • header_row()
      • table()
      • table_data()
      • table_header()
      • table_type()
      • table_type_columns()
      • table_type_name()
      • table_type_with_columns()
      • table_type_with_name()
      • table_with_data()
      • table_with_header()
      • un_data_row()
      • un_header_row()
    • hydra.dsl.testing module
      • effectful_test_case()
      • effectful_test_case_actual()
      • effectful_test_case_expected()
      • effectful_test_case_with_actual()
      • effectful_test_case_with_expected()
      • tag()
      • test_case_effectful()
      • test_case_universal()
      • test_case_with_metadata()
      • test_case_with_metadata_case()
      • test_case_with_metadata_description()
      • test_case_with_metadata_name()
      • test_case_with_metadata_tags()
      • test_case_with_metadata_with_case()
      • test_case_with_metadata_with_description()
      • test_case_with_metadata_with_name()
      • test_case_with_metadata_with_tags()
      • test_group()
      • test_group_cases()
      • test_group_description()
      • test_group_name()
      • test_group_subgroups()
      • test_group_with_cases()
      • test_group_with_description()
      • test_group_with_name()
      • test_group_with_subgroups()
      • un_tag()
      • universal_test_case()
      • universal_test_case_actual()
      • universal_test_case_expected()
      • universal_test_case_with_actual()
      • universal_test_case_with_expected()
    • hydra.dsl.time module
      • timespec()
      • timespec_nanoseconds()
      • timespec_seconds()
      • timespec_with_nanoseconds()
      • timespec_with_seconds()
    • hydra.dsl.topology module
      • decode_ordering_isomorphism()
      • encode_ordering_isomorphism()
      • ordering_isomorphism()
      • ordering_isomorphism_decode()
      • ordering_isomorphism_encode()
      • ordering_isomorphism_with_decode()
      • ordering_isomorphism_with_encode()
      • tarjan_state()
      • tarjan_state_counter()
      • tarjan_state_indices()
      • tarjan_state_low_links()
      • tarjan_state_on_stack()
      • tarjan_state_sccs()
      • tarjan_state_stack()
      • tarjan_state_with_counter()
      • tarjan_state_with_indices()
      • tarjan_state_with_low_links()
      • tarjan_state_with_on_stack()
      • tarjan_state_with_sccs()
      • tarjan_state_with_stack()
    • hydra.dsl.typing module
      • decode_function_structure()
      • encode_function_structure()
      • function_structure()
      • function_structure_bindings()
      • function_structure_body()
      • function_structure_codomain()
      • function_structure_domains()
      • function_structure_environment()
      • function_structure_params()
      • function_structure_type_params()
      • function_structure_with_bindings()
      • function_structure_with_body()
      • function_structure_with_codomain()
      • function_structure_with_domains()
      • function_structure_with_environment()
      • function_structure_with_params()
      • function_structure_with_type_params()
      • inference_context()
      • inference_context_fresh_type_variable_count()
      • inference_context_trace()
      • inference_context_with_fresh_type_variable_count()
      • inference_context_with_trace()
      • inference_result()
      • inference_result_class_constraints()
      • inference_result_context()
      • inference_result_subst()
      • inference_result_term()
      • inference_result_type()
      • inference_result_with_class_constraints()
      • inference_result_with_context()
      • inference_result_with_subst()
      • inference_result_with_term()
      • inference_result_with_type()
      • parameter()
      • parameter_description()
      • parameter_is_lazy()
      • parameter_name()
      • parameter_type()
      • parameter_with_description()
      • parameter_with_is_lazy()
      • parameter_with_name()
      • parameter_with_type()
      • result()
      • result_description()
      • result_type()
      • result_with_description()
      • result_with_type()
      • term_signature()
      • term_signature_parameters()
      • term_signature_result()
      • term_signature_type_parameters()
      • term_signature_with_parameters()
      • term_signature_with_result()
      • term_signature_with_type_parameters()
      • term_subst()
      • type_class()
      • type_class_description()
      • type_class_with_description()
      • type_constraint()
      • type_constraint_comment()
      • type_constraint_left()
      • type_constraint_right()
      • type_constraint_with_comment()
      • type_constraint_with_left()
      • type_constraint_with_right()
      • type_parameter()
      • type_parameter_constraints()
      • type_parameter_name()
      • type_parameter_with_constraints()
      • type_parameter_with_name()
      • type_subst()
      • un_term_subst()
      • un_type_subst()
    • hydra.dsl.util module
      • decode_module_names()
      • encode_module_names()
      • module_names()
      • module_names_focus()
      • module_names_mapping()
      • module_names_with_focus()
      • module_names_with_mapping()
      • precision_bits()
      • qualified_name()
      • qualified_name_local()
      • qualified_name_module_name()
      • qualified_name_with_local()
      • qualified_name_with_module_name()
    • hydra.dsl.validation module
      • decode_validation_result()
      • encode_validation_result()
      • validation_profile()
      • validation_profile_error_rules()
      • validation_profile_max_errors()
      • validation_profile_max_warnings()
      • validation_profile_warning_rules()
      • validation_profile_with_error_rules()
      • validation_profile_with_max_errors()
      • validation_profile_with_max_warnings()
      • validation_profile_with_warning_rules()
      • validation_result()
      • validation_result_errors()
      • validation_result_warnings()
      • validation_result_with_errors()
      • validation_result_with_warnings()
    • hydra.dsl.variables module
      • free_type_variables_in_term()
      • free_variables_in_term()
      • free_variables_in_type()
      • free_variables_in_type_ordered()
      • free_variables_in_type_scheme()
      • free_variables_in_type_scheme_simple()
      • free_variables_in_type_simple()
      • is_free_variable_in_term()
      • normalize_type_variables_in_term()
      • replace_free_term_variable()
      • replace_free_type_variable()
      • substitute_type_variables()
      • substitute_variable()
      • substitute_variables()
      • unshadow_variables()
    • hydra.dsl.variants module
• hydra.encode namespace
  • Subpackages
    • hydra.encode.error namespace
      • Submodules
    • hydra.encode.json namespace
      • Submodules
    • hydra.encode.yaml namespace
      • Submodules
  • Submodules
    • hydra.encode.ast module
      • associativity()
      • block_style()
      • bracket_expr()
      • brackets()
      • expr()
      • indent_style()
      • indented_expression()
      • op()
      • op_expr()
      • padding()
      • precedence()
      • seq_expr()
      • symbol()
      • ws()
    • hydra.encode.coders module
      • case_conventions()
      • coder_direction()
      • language_feature()
      • language_name()
      • traversal_order()
    • hydra.encode.core module
      • annotated_term()
      • annotated_type()
      • application()
      • application_type()
      • binding()
      • case_alternative()
      • case_statement()
      • either_type()
      • field()
      • field_type()
      • float_type()
      • float_value()
      • forall_type()
      • function_type()
      • injection()
      • integer_type()
      • integer_value()
      • lambda_()
      • let()
      • literal()
      • literal_type()
      • map_type()
      • name()
      • pair_type()
      • projection()
      • record()
      • term()
      • type()
      • type_application_term()
      • type_class_constraint()
      • type_lambda()
      • type_scheme()
      • type_variable_constraints()
      • wrapped_term()
    • hydra.encode.docs module
      • doc_segment()
    • hydra.encode.errors module
      • decoding_error()
      • empty_list_error()
      • error()
      • extraction_error()
      • inference_error()
      • multiple_bindings_error()
      • multiple_fields_error()
      • no_matching_field_error()
      • no_such_binding_error()
      • no_such_primitive_error()
      • not_enough_cases_error()
      • other_error()
      • other_inference_error()
      • other_resolution_error()
      • resolution_error()
      • unexpected_shape_error()
      • unification_error()
      • unification_inference_error()
    • hydra.encode.file module
      • file_extension()
      • file_path()
      • file_status()
      • file_type()
    • hydra.encode.packaging module
      • definition()
      • definition_reference()
      • dependency_scope()
      • entity_metadata()
      • entity_reference()
      • lifecycle_info()
      • module()
      • module_dependency()
      • module_name()
      • package()
      • package_dependency()
      • package_name()
      • primitive_definition()
      • term_definition()
      • type_definition()
      • version()
      • version_range()
      • version_specifier()
    • hydra.encode.parsing module
      • parse_error()
      • parse_result()
      • parse_success()
    • hydra.encode.paths module
      • subterm_attribute()
      • subterm_edge()
      • subterm_graph()
      • subterm_link()
      • subterm_node()
      • subterm_path()
      • subterm_property()
      • subterm_step()
      • subtype_attribute()
      • subtype_edge()
      • subtype_graph()
      • subtype_link()
      • subtype_node()
      • subtype_path()
      • subtype_property()
      • subtype_step()
      • term_attribute()
      • type_attribute()
    • hydra.encode.query module
      • comparison_constraint()
      • edge()
      • graph_pattern()
      • node()
      • path()
      • path_equation()
      • pattern()
      • pattern_implication()
      • query()
      • range_()
      • regex_quantifier()
      • regex_sequence()
      • step()
      • triple_pattern()
      • variable()
    • hydra.encode.regex module
      • alternation()
      • atom()
      • character_class()
      • character_range()
      • class_item()
      • quantified()
      • quantifier()
      • quantifier_range()
      • regex()
      • regex_sequence()
    • hydra.encode.relational module
      • column_name()
      • column_schema()
      • foreign_key()
      • primary_key()
      • relation()
      • relation_name()
      • relation_schema()
      • relationship()
      • row()
    • hydra.encode.system module
      • command()
      • environment_variable()
      • process_result()
      • status_code()
    • hydra.encode.tabular module
      • column_type()
      • data_row()
      • header_row()
      • table()
      • table_type()
    • hydra.encode.testing module
      • tag()
    • hydra.encode.time module
      • timespec()
    • hydra.encode.topology module
      • graph()
      • tarjan_state()
      • vertex()
    • hydra.encode.typed module
      • typed_binding()
      • typed_name()
      • typed_term()
      • typed_term_definition()
    • hydra.encode.typing module
      • function_structure()
      • inference_context()
      • inference_result()
      • parameter()
      • result()
      • term_signature()
      • term_subst()
      • type_class()
      • type_constraint()
      • type_parameter()
      • type_subst()
    • hydra.encode.util module
      • case_convention()
      • comparison()
      • module_names()
      • precision()
      • qualified_name()
    • hydra.encode.validation module
      • validation_profile()
      • validation_result()
    • hydra.encode.variants module
      • literal_variant()
      • term_variant()
      • type_variant()
• hydra.error namespace
  • Submodules
    • hydra.error.checking module
      • CheckingError
      • CheckingErrorIncorrectUnification
      • CheckingErrorNotAForallType
      • CheckingErrorNotAFunctionType
      • CheckingErrorOther
      • CheckingErrorTypeArityMismatch
      • CheckingErrorTypeMismatch
      • CheckingErrorUnboundTypeVariables
      • CheckingErrorUndefinedTermVariable
      • CheckingErrorUnequalTypes
      • CheckingErrorUnsupportedTermVariant
      • CheckingErrorUntypedLambda
      • CheckingErrorUntypedLetBinding
      • CheckingErrorUntypedTermVariable
      • IncorrectUnificationError
      • NotAForallTypeError
      • NotAFunctionTypeError
      • OtherCheckingError
      • TypeArityMismatchError
      • TypeMismatchError
      • UnboundTypeVariablesError
      • UndefinedTermVariableCheckingError
      • UnequalTypesError
      • UnsupportedTermVariantError
      • UntypedLambdaError
      • UntypedLetBindingError
      • UntypedTermVariableCheckingError
    • hydra.error.core module
      • ConstantConditionError
      • DuplicateBindingError
      • DuplicateFieldError
      • DuplicateRecordTypeFieldNamesError
      • DuplicateUnionTypeFieldNamesError
      • EmptyCaseStatementError
      • EmptyLetBindingsError
      • EmptyRecordTypeError
      • EmptyTermAnnotationError
      • EmptyTypeAnnotationError
      • EmptyTypeNameInTermError
      • EmptyUnionTypeError
      • ExtraRecordFieldsError
      • InvalidForallParameterNameError
      • InvalidLambdaParameterNameError
      • InvalidLetBindingNameError
      • InvalidLiteralError
      • InvalidLiteralErrorTypeMismatch
      • InvalidTermError
      • InvalidTermErrorConstantCondition
      • InvalidTermErrorDuplicateBinding
      • InvalidTermErrorDuplicateField
      • InvalidTermErrorEmptyCaseStatement
      • InvalidTermErrorEmptyLetBindings
      • InvalidTermErrorEmptyTermAnnotation
      • InvalidTermErrorEmptyTypeNameInTerm
      • InvalidTermErrorExtraRecordFields
      • InvalidTermErrorInvalidLambdaParameterName
      • InvalidTermErrorInvalidLetBindingName
      • InvalidTermErrorInvalidTypeLambdaParameterName
      • InvalidTermErrorMissingCaseBranches
      • InvalidTermErrorMissingRecordFields
      • InvalidTermErrorNestedTermAnnotation
      • InvalidTermErrorNominalTypeKindMismatch
      • InvalidTermErrorRedundantWrapUnwrap
      • InvalidTermErrorSelfApplication
      • InvalidTermErrorTermVariableShadowing
      • InvalidTermErrorTypeVariableShadowingInTypeLambda
      • InvalidTermErrorUndeclaredVariant
      • InvalidTermErrorUndefinedTermVariable
      • InvalidTermErrorUndefinedTypeVariableInBindingType
      • InvalidTermErrorUndefinedTypeVariableInLambdaDomain
      • InvalidTermErrorUndefinedTypeVariableInTypeApplication
      • InvalidTermErrorUnknownCaseAlternative
      • InvalidTermErrorUnknownPrimitiveName
      • InvalidTermErrorUnknownProjectedField
      • InvalidTermErrorUnnecessaryIdentityApplication
      • InvalidTermErrorUnresolvedNominalType
      • InvalidTermErrorUntypedTermVariable
      • InvalidTypeError
      • InvalidTypeErrorDuplicateRecordTypeFieldNames
      • InvalidTypeErrorDuplicateUnionTypeFieldNames
      • InvalidTypeErrorEmptyRecordType
      • InvalidTypeErrorEmptyTypeAnnotation
      • InvalidTypeErrorEmptyUnionType
      • InvalidTypeErrorInvalidForallParameterName
      • InvalidTypeErrorInvalidTypeSchemeVariableName
      • InvalidTypeErrorNestedTypeAnnotation
      • InvalidTypeErrorNonComparableMapKeyType
      • InvalidTypeErrorNonComparableSetElementType
      • InvalidTypeErrorSingleVariantUnion
      • InvalidTypeErrorTypeVariableShadowingInForall
      • InvalidTypeErrorUndefinedTypeVariable
      • InvalidTypeErrorVoidInNonBottomPosition
      • InvalidTypeLambdaParameterNameError
      • InvalidTypeSchemeVariableNameError
      • LiteralTypeMismatchError
      • MissingCaseBranchesError
      • MissingRecordFieldsError
      • NestedTermAnnotationError
      • NestedTypeAnnotationError
      • NominalTypeKindMismatchError
      • NonComparableMapKeyTypeError
      • NonComparableSetElementTypeError
      • RedundantWrapUnwrapError
      • SelfApplicationError
      • SingleVariantUnionError
      • TermVariableShadowingError
      • TypeVariableShadowingInForallError
      • TypeVariableShadowingInTypeLambdaError
      • UndeclaredVariantError
      • UndefinedFieldError
      • UndefinedTermVariableError
      • UndefinedTypeVariableError
      • UndefinedTypeVariableInBindingTypeError
      • UndefinedTypeVariableInLambdaDomainError
      • UndefinedTypeVariableInTypeApplicationError
      • UnexpectedTermVariantError
      • UnexpectedTypeVariantError
      • UnknownCaseAlternativeError
      • UnknownPrimitiveNameError
      • UnknownProjectedFieldError
      • UnnecessaryIdentityApplicationError
      • UnresolvedNominalTypeError
      • UntypedTermVariableError
      • VoidInNonBottomPositionError
    • hydra.error.file module
      • FileError
      • FileErrorAlreadyExists
      • FileErrorInvalidPath
      • FileErrorNotFound
      • FileErrorOther
      • FileErrorPermissionDenied
    • hydra.error.packaging module
      • ConflictingModuleNameError
      • ConflictingVariantNameError
      • DefinitionNotInModuleNameError
      • DefinitionsOutOfOrderError
      • DuplicateDefinitionNameError
      • DuplicateModuleNameError
      • InvalidDefinitionNameError
      • InvalidModuleError
      • InvalidModuleErrorConflictingVariantName
      • InvalidModuleErrorDefinitionNotInModuleName
      • InvalidModuleErrorDefinitionsOutOfOrder
      • InvalidModuleErrorDuplicateDefinitionName
      • InvalidModuleErrorInvalidDefinitionName
      • InvalidModuleErrorInvalidModuleNameConvention
      • InvalidModuleErrorMissingDocumentation
      • InvalidModuleNameConventionError
      • InvalidPackageError
      • InvalidPackageErrorConflictingModuleName
      • InvalidPackageErrorDuplicateModuleName
      • InvalidPackageErrorInvalidModule
      • InvalidPackageErrorInvalidPackageName
      • InvalidPackageErrorUndeclaredDependency
      • InvalidPackageNameError
      • MissingDocumentationError
      • UndeclaredDependencyError
    • hydra.error.system module
      • SystemError
      • SystemErrorCommandNotFound
      • SystemErrorInterrupted
      • SystemErrorInvalidWorkingDirectory
      • SystemErrorOther
      • SystemErrorPermissionDenied
• hydra.extract namespace
  • Submodules
    • hydra.extract.core module
      • bigint()
      • bigint_value()
      • binary()
      • binary_literal()
      • boolean()
      • boolean_literal()
      • cases()
      • decimal()
      • decimal_literal()
      • decode_either()
      • decode_list()
      • decode_map()
      • decode_maybe()
      • decode_pair()
      • decode_set()
      • decode_unit()
      • either_term()
      • either_type()
      • field()
      • float32()
      • float32_value()
      • float64()
      • float64_value()
      • float_literal()
      • float_value()
      • function_type()
      • injection()
      • int16()
      • int16_value()
      • int32()
      • int32_value()
      • int64()
      • int64_value()
      • int8()
      • int8_value()
      • integer_literal()
      • integer_value()
      • lambda_()
      • lambda_body()
      • let()
      • let_binding()
      • list()
      • list_of()
      • list_type()
      • literal()
      • map()
      • map_type()
      • n_args()
      • optional_term()
      • optional_type()
      • pair()
      • record()
      • record_type()
      • require_field()
      • set()
      • set_of()
      • set_type()
      • string()
      • string_literal()
      • strip_with_decoding_error()
      • term_record()
      • to_field_map()
      • uint16()
      • uint16_value()
      • uint32()
      • uint32_value()
      • uint64()
      • uint64_value()
      • uint8()
      • uint8_value()
      • union_type()
      • unit()
      • unit_variant()
      • wrap()
      • wrapped_type()
    • hydra.extract.json module
      • expect_array()
      • expect_number()
      • expect_object()
      • expect_string()
      • opt()
      • opt_array()
      • opt_string()
      • require()
      • require_array()
      • require_number()
      • require_string()
      • show_value()
    • hydra.extract.util module
      • comparison()
• hydra.json namespace
  • Subpackages
    • hydra.json.yaml namespace
      • Submodules
  • Submodules
    • hydra.json.bootstrap module
    • hydra.json.decode module
      • decode_float()
      • decode_integer()
      • decode_literal()
      • expect_array()
      • expect_number()
      • expect_object()
      • expect_string()
      • from_json()
      • parse_special_float()
      • parse_special_float32()
    • hydra.json.decoding module
      • decode_array()
      • decode_boolean()
      • decode_field()
      • decode_object()
      • decode_optional_field()
      • decode_string()
    • hydra.json.encode module
      • encode_float()
      • encode_integer()
      • encode_literal()
      • requires_json_string_sentinel()
      • to_json()
      • to_json_untyped()
    • hydra.json.model module
      • Value
      • ValueArray
      • ValueBoolean
      • ValueNull
      • ValueNumber
      • ValueObject
      • ValueString
    • hydra.json.parser module
      • digit()
      • digits()
      • json_array()
      • json_bool()
      • json_escape_char()
      • json_exponent_part()
      • json_fraction_part()
      • json_integer_part()
      • json_key_value()
      • json_null()
      • json_number()
      • json_object()
      • json_string()
      • json_string_char()
      • json_value()
      • parse_json()
      • token()
      • whitespace()
    • hydra.json.writer module
      • hex_byte()
      • json_string()
      • key_value_to_expr()
      • print_json()
      • value_to_expr()
• hydra.lib namespace
  • Submodules
    • hydra.lib.chars module
    • hydra.lib.defaults module
      • default_implementations()
    • hydra.lib.effects module
    • hydra.lib.eithers module
    • hydra.lib.equality module
    • hydra.lib.files module
    • hydra.lib.functions module
    • hydra.lib.hashing module
    • hydra.lib.lists module
    • hydra.lib.literals module
    • hydra.lib.logic module
    • hydra.lib.maps module
    • hydra.lib.math module
    • hydra.lib.optionals module
    • hydra.lib.ordering module
    • hydra.lib.pairs module
    • hydra.lib.regex module
    • hydra.lib.sets module
    • hydra.lib.strings module
    • hydra.lib.system module
    • hydra.lib.text module
• hydra.overlay package
  • Subpackages
    • hydra.overlay.python package
      • Subpackages
      • Submodules
      • Module contents
  • Module contents
• hydra.parse namespace
  • Submodules
    • hydra.parse.docs module
      • parse_doc_annotation()
      • parse_doc_string()
    • hydra.parse.regex module
      • alternation()
      • atom()
      • character_class()
      • class_item()
      • escaped_char()
      • is_metachar()
      • literal_atom()
      • parse_regex()
      • quantified()
      • quantifier()
      • regex()
      • regex_sequence()
      • unsigned_int()
• hydra.print namespace
  • Subpackages
    • hydra.print.emacs namespace
      • Submodules
    • hydra.print.error namespace
      • Submodules
    • hydra.print.pcre namespace
      • Submodules
    • hydra.print.posix namespace
      • Submodules
  • Submodules
    • hydra.print.core module
      • binding()
      • case_statement()
      • either()
      • field()
      • field_type()
      • fields()
      • float()
      • float_type()
      • injection()
      • integer()
      • integer_type()
      • lambda_()
      • let()
      • list()
      • literal()
      • literal_type()
      • map()
      • optional()
      • pair()
      • projection()
      • read_term()
      • set()
      • term()
      • type()
      • type_scheme()
    • hydra.print.docs module
      • definition_reference()
      • doc_segment()
      • doc_segment_with()
      • doc_segments()
      • doc_segments_with()
      • entity_reference()
      • render_doc_string()
      • render_doc_string_with()
    • hydra.print.errors module
      • checking_error()
      • decoding_error()
      • error()
      • incorrect_unification_error()
      • not_a_forall_type_error()
      • not_a_function_type_error()
      • other_error()
      • resolution_error()
      • type_arity_mismatch_error()
      • type_mismatch_error()
      • unbound_type_variables_error()
      • unequal_types_error()
      • unification_error()
      • unsupported_term_variant_error()
      • untyped_lambda_error()
      • untyped_let_binding_error()
    • hydra.print.graph module
      • graph()
    • hydra.print.paths module
      • parse_subterm_path()
      • parse_subterm_step()
      • parse_subtype_path()
      • parse_subtype_step()
      • subterm_path()
      • subterm_step()
      • subtype_path()
      • subtype_step()
    • hydra.print.regex module
      • alternation()
      • atom()
      • character_class()
      • class_item()
      • escape_class_char()
      • escape_literal()
      • print_code_point()
      • print_regex()
      • quantified()
      • quantifier()
      • regex_sequence()
    • hydra.print.typing module
      • type_constraint()
      • type_subst()
    • hydra.print.util module
      • case_convention()
      • comparison()
    • hydra.print.variants module
      • term_variant()
      • type_variant()
• hydra.test namespace
  • Submodules
    • hydra.test.transform module
      • add_generation_prefix()
      • build_convert_case_call()
      • build_topological_sort_call()
      • build_topological_sort_s_c_c_call()
      • collect_test_cases()
      • encode_adjacency_list()
      • encode_case_convention()
      • encode_either_list_list()
      • encode_int()
      • encode_int_list()
      • encode_list_list()
      • transform_module()
      • transform_test_case()
      • transform_to_compiled_tests()
    • hydra.test.utils module
      • infer_term()
      • infer_test_case()
      • infer_test_group_terms()
• hydra.validate namespace
  • Submodules
    • hydra.validate.core module
      • append_finding()
      • append_finding_type()
      • check_duplicate_bindings()
      • check_duplicate_field_types()
      • check_duplicate_fields()
      • check_literal()
      • check_shadowing()
      • check_term()
      • check_undefined_type_variables_in_type()
      • check_undefined_type_variables_in_type_scheme()
      • check_void()
      • enabled()
      • find_duplicate()
      • find_duplicate_field_type()
      • first_error()
      • first_finding()
      • first_finding_type()
      • first_type_error()
      • is_valid_name()
      • kernel_default_core_profile()
      • resolve_nominal_type()
      • resolve_record_fields()
      • resolve_union_fields()
      • term()
      • type()
      • validate_type_node()
    • hydra.validate.packaging module
      • append_finding_module()
      • append_finding_package()
      • check_conflicting_module_names()
      • check_conflicting_variant_names()
      • check_definition_documentation()
      • check_definition_module_names()
      • check_definition_name_convention()
      • check_definition_ordering()
      • check_duplicate_definition_names()
      • check_duplicate_module_names()
      • check_module_name_convention()
      • check_package_name_convention()
      • check_undeclared_dependencies()
      • definition_name()
      • enabled_packaging()
      • kernel_default_packaging_profile()
      • kernel_module()
      • kernel_package()
      • kernel_packaging_profile_with_doc_warnings()
      • kernel_universe_undeclared_dependencies()
      • module()
      • package()
      • undeclared_dependency_owners()
• hydra.yaml namespace
  • Submodules
    • hydra.yaml.model module
      • NodeMapping
      • NodeScalar
      • NodeSequence
      • Node_
      • Scalar
      • ScalarBool
      • ScalarDecimal
      • ScalarFloat
      • ScalarInt
      • ScalarNull
      • ScalarStr

Submodules

• hydra.adapt module
  • adapt_data_graph()
  • adapt_float_type()
  • adapt_graph_schema()
  • adapt_integer_type()
  • adapt_lambda_domains()
  • adapt_literal()
  • adapt_literal_type()
  • adapt_literal_types_map()
  • adapt_literal_value()
  • adapt_nested_types()
  • adapt_primitive()
  • adapt_term()
  • adapt_term_for_language()
  • adapt_term_signature()
  • adapt_type()
  • adapt_type_for_language()
  • adapt_type_scheme()
  • compose_coders()
  • data_graph_to_definitions()
  • literal_type_supported()
  • prepare_float_type()
  • prepare_integer_type()
  • prepare_literal_type()
  • prepare_same()
  • prepare_type()
  • push_type_apps_inward()
  • schema_graph_to_definitions()
  • simple_language_adapter()
  • term_alternatives()
  • type_alternatives()
• hydra.analysis module
  • add_names_to_module_names()
  • analyze_function_term()
  • analyze_function_term_with()
  • analyze_function_term_with_finish()
  • analyze_function_term_with_gather()
  • definition_dependency_module_names()
  • dependency_module_names()
  • gather_applications()
  • gather_args()
  • gather_args_with_type_apps()
  • is_self_tail_recursive()
  • is_simple_assignment()
  • is_tail_recursive_in_tail_position()
  • module_contains_binary_literals()
  • module_contains_decimal_literals()
  • module_dependency_module_names()
  • module_names_for_definitions()
• hydra.annotations module
  • aggregate_annotations()
  • comments_from_binding()
  • comments_from_field_type()
  • get_annotation_map()
  • get_description()
  • get_term_annotation()
  • get_term_description()
  • get_type()
  • get_type_annotation()
  • get_type_classes()
  • get_type_description()
  • has_description()
  • has_type_description()
  • is_native_type()
  • normalize_term_annotations()
  • normalize_type_annotations()
  • set_annotation()
  • set_description()
  • set_term_annotation()
  • set_term_description()
  • set_type()
  • set_type_annotation()
  • set_type_classes()
  • set_type_description()
  • term_annotation_internal()
  • type_annotation_internal()
  • wrap_annotation_map()
• hydra.arity module
  • primitive_arity()
  • term_arity()
  • type_arity()
  • type_scheme_arity()
  • uncurry_type()
• hydra.ast module
  • Associativity
    • Associativity.BOTH
    • Associativity.LEFT
    • Associativity.NONE
    • Associativity.RIGHT
    • Associativity.TYPE_
  • BlockStyle
    • BlockStyle.Builder
      • BlockStyle.Builder.build()
      • BlockStyle.Builder.indent()
      • BlockStyle.Builder.newline_after_content()
      • BlockStyle.Builder.newline_before_content()
    • BlockStyle.INDENT
    • BlockStyle.NEWLINE_AFTER_CONTENT
    • BlockStyle.NEWLINE_BEFORE_CONTENT
    • BlockStyle.TYPE_
    • BlockStyle.builder()
    • BlockStyle.indent
    • BlockStyle.newline_after_content
    • BlockStyle.newline_before_content
    • BlockStyle.with_indent()
    • BlockStyle.with_newline_after_content()
    • BlockStyle.with_newline_before_content()
  • BracketExpr
    • BracketExpr.BRACKETS
    • BracketExpr.Builder
      • BracketExpr.Builder.brackets()
      • BracketExpr.Builder.build()
      • BracketExpr.Builder.enclosed()
      • BracketExpr.Builder.style()
    • BracketExpr.ENCLOSED
    • BracketExpr.STYLE
    • BracketExpr.TYPE_
    • BracketExpr.brackets
    • BracketExpr.builder()
    • BracketExpr.enclosed
    • BracketExpr.style
    • BracketExpr.with_brackets()
    • BracketExpr.with_enclosed()
    • BracketExpr.with_style()
  • Brackets
    • Brackets.Builder
      • Brackets.Builder.build()
      • Brackets.Builder.close()
      • Brackets.Builder.open()
    • Brackets.CLOSE
    • Brackets.OPEN
    • Brackets.TYPE_
    • Brackets.builder()
    • Brackets.close
    • Brackets.open
    • Brackets.with_close()
    • Brackets.with_open()
  • Expr
    • Expr.BRACKETS
    • Expr.CONST
    • Expr.INDENT
    • Expr.OP
    • Expr.SEQ
    • Expr.TYPE_
  • ExprBrackets
  • ExprConst
  • ExprIndent
  • ExprOp
  • ExprSeq
  • IndentStyle
    • IndentStyle.ALL_LINES
    • IndentStyle.SUBSEQUENT_LINES
    • IndentStyle.TYPE_
  • IndentStyleAllLines
  • IndentStyleSubsequentLines
  • IndentedExpression
    • IndentedExpression.Builder
      • IndentedExpression.Builder.build()
      • IndentedExpression.Builder.expr()
      • IndentedExpression.Builder.style()
    • IndentedExpression.EXPR
    • IndentedExpression.STYLE
    • IndentedExpression.TYPE_
    • IndentedExpression.builder()
    • IndentedExpression.expr
    • IndentedExpression.style
    • IndentedExpression.with_expr()
    • IndentedExpression.with_style()
  • Op
    • Op.ASSOCIATIVITY
    • Op.Builder
      • Op.Builder.associativity()
      • Op.Builder.build()
      • Op.Builder.padding()
      • Op.Builder.precedence()
      • Op.Builder.symbol()
    • Op.PADDING
    • Op.PRECEDENCE
    • Op.SYMBOL
    • Op.TYPE_
    • Op.associativity
    • Op.builder()
    • Op.padding
    • Op.precedence
    • Op.symbol
    • Op.with_associativity()
    • Op.with_padding()
    • Op.with_precedence()
    • Op.with_symbol()
  • OpExpr
    • OpExpr.Builder
      • OpExpr.Builder.build()
      • OpExpr.Builder.lhs()
      • OpExpr.Builder.op()
      • OpExpr.Builder.rhs()
    • OpExpr.LHS
    • OpExpr.OP
    • OpExpr.RHS
    • OpExpr.TYPE_
    • OpExpr.builder()
    • OpExpr.lhs
    • OpExpr.op
    • OpExpr.rhs
    • OpExpr.with_lhs()
    • OpExpr.with_op()
    • OpExpr.with_rhs()
  • Padding
    • Padding.Builder
      • Padding.Builder.build()
      • Padding.Builder.left()
      • Padding.Builder.right()
    • Padding.LEFT
    • Padding.RIGHT
    • Padding.TYPE_
    • Padding.builder()
    • Padding.left
    • Padding.right
    • Padding.with_left()
    • Padding.with_right()
  • Precedence
    • Precedence.TYPE_
  • SeqExpr
    • SeqExpr.Builder
      • SeqExpr.Builder.build()
      • SeqExpr.Builder.elements()
      • SeqExpr.Builder.op()
    • SeqExpr.ELEMENTS
    • SeqExpr.OP
    • SeqExpr.TYPE_
    • SeqExpr.builder()
    • SeqExpr.elements
    • SeqExpr.op
    • SeqExpr.with_elements()
    • SeqExpr.with_op()
  • Symbol
    • Symbol.TYPE_
  • Ws
    • Ws.BREAK
    • Ws.BREAK_AND_INDENT
    • Ws.DOUBLE_BREAK
    • Ws.NONE
    • Ws.SPACE
    • Ws.TYPE_
  • WsBreak
  • WsBreakAndIndent
  • WsDoubleBreak
  • WsNone
  • WsSpace
• hydra.checking module
  • all_equal()
  • apply_type_arguments_to_type()
  • check_for_unbound_type_variables()
  • check_same_type()
  • check_type_subst()
  • contains_in_scope_type_vars()
  • normalize_type_free_vars()
  • to_f_context()
  • type_lists_effectively_equal()
  • type_of()
  • type_of_annotated_term()
  • type_of_application()
  • type_of_case_statement()
  • type_of_either()
  • type_of_injection()
  • type_of_lambda()
  • type_of_let()
  • type_of_list()
  • type_of_literal()
  • type_of_map()
  • type_of_maybe()
  • type_of_pair()
  • type_of_primitive()
  • type_of_projection()
  • type_of_record()
  • type_of_set()
  • type_of_term()
  • type_of_type_application()
  • type_of_type_lambda()
  • type_of_unit()
  • type_of_unwrap()
  • type_of_variable()
  • type_of_wrapped_term()
  • types_all_effectively_equal()
  • types_effectively_equal()
• hydra.classes module
  • class_is_satisfied_by_type()
• hydra.codegen module
  • build_schema_map()
  • decode_module_from_json()
  • escape_control_chars_in_json()
  • format_primitive()
  • format_term_binding()
  • format_type_binding()
  • generate_coder_modules()
  • generate_lexicon()
  • generate_source_files()
  • infer_and_generate_lexicon()
  • infer_modules()
  • infer_modules_given()
  • lower_primitive_definitions()
  • module_deps_transitive()
  • module_name_to_path()
  • module_to_json()
  • module_to_source_module()
  • modules_to_graph()
  • refresh_module()
  • transitive_deps()
• hydra.coders module
  • Adapter
    • Adapter.Builder
      • Adapter.Builder.build()
      • Adapter.Builder.coder()
      • Adapter.Builder.is_lossy()
      • Adapter.Builder.source()
      • Adapter.Builder.target()
    • Adapter.CODER
    • Adapter.IS_LOSSY
    • Adapter.SOURCE
    • Adapter.TARGET
    • Adapter.TYPE_
    • Adapter.builder()
    • Adapter.coder
    • Adapter.is_lossy
    • Adapter.source
    • Adapter.target
    • Adapter.with_coder()
    • Adapter.with_is_lossy()
    • Adapter.with_source()
    • Adapter.with_target()
  • AdapterContext
    • AdapterContext.ADAPTERS
    • AdapterContext.Builder
      • AdapterContext.Builder.adapters()
      • AdapterContext.Builder.build()
      • AdapterContext.Builder.graph()
      • AdapterContext.Builder.language()
    • AdapterContext.GRAPH
    • AdapterContext.LANGUAGE
    • AdapterContext.TYPE_
    • AdapterContext.adapters
    • AdapterContext.builder()
    • AdapterContext.graph
    • AdapterContext.language
    • AdapterContext.with_adapters()
    • AdapterContext.with_graph()
    • AdapterContext.with_language()
  • Bicoder
    • Bicoder.Builder
      • Bicoder.Builder.build()
      • Bicoder.Builder.decode()
      • Bicoder.Builder.encode()
    • Bicoder.DECODE
    • Bicoder.ENCODE
    • Bicoder.TYPE_
    • Bicoder.builder()
    • Bicoder.decode
    • Bicoder.encode
    • Bicoder.with_decode()
    • Bicoder.with_encode()
  • CaseConventions
    • CaseConventions.Builder
      • CaseConventions.Builder.build()
      • CaseConventions.Builder.constant()
      • CaseConventions.Builder.directory()
      • CaseConventions.Builder.enum_value()
      • CaseConventions.Builder.field()
      • CaseConventions.Builder.file()
      • CaseConventions.Builder.module()
      • CaseConventions.Builder.term()
      • CaseConventions.Builder.term_variable()
      • CaseConventions.Builder.type()
      • CaseConventions.Builder.type_variable()
    • CaseConventions.CONSTANT
    • CaseConventions.DIRECTORY
    • CaseConventions.ENUM_VALUE
    • CaseConventions.FIELD
    • CaseConventions.FILE
    • CaseConventions.MODULE
    • CaseConventions.TERM
    • CaseConventions.TERM_VARIABLE
    • CaseConventions.TYPE
    • CaseConventions.TYPE_
    • CaseConventions.TYPE_VARIABLE
    • CaseConventions.builder()
    • CaseConventions.constant
    • CaseConventions.directory
    • CaseConventions.enum_value
    • CaseConventions.field
    • CaseConventions.file
    • CaseConventions.module
    • CaseConventions.term
    • CaseConventions.term_variable
    • CaseConventions.type
    • CaseConventions.type_variable
    • CaseConventions.with_constant()
    • CaseConventions.with_directory()
    • CaseConventions.with_enum_value()
    • CaseConventions.with_field()
    • CaseConventions.with_file()
    • CaseConventions.with_module()
    • CaseConventions.with_term()
    • CaseConventions.with_term_variable()
    • CaseConventions.with_type()
    • CaseConventions.with_type_variable()
  • Coder
    • Coder.Builder
      • Coder.Builder.build()
      • Coder.Builder.decode()
      • Coder.Builder.encode()
    • Coder.DECODE
    • Coder.ENCODE
    • Coder.TYPE_
    • Coder.builder()
    • Coder.decode
    • Coder.encode
    • Coder.with_decode()
    • Coder.with_encode()
  • CoderDirection
    • CoderDirection.DECODE
    • CoderDirection.ENCODE
    • CoderDirection.TYPE_
  • Language
    • Language.Builder
      • Language.Builder.build()
      • Language.Builder.case_conventions()
      • Language.Builder.constraints()
      • Language.Builder.default_file_extension()
      • Language.Builder.name()
      • Language.Builder.supported_features()
    • Language.CASE_CONVENTIONS
    • Language.CONSTRAINTS
    • Language.DEFAULT_FILE_EXTENSION
    • Language.NAME
    • Language.SUPPORTED_FEATURES
    • Language.TYPE_
    • Language.builder()
    • Language.case_conventions
    • Language.constraints
    • Language.default_file_extension
    • Language.name
    • Language.supported_features
    • Language.with_case_conventions()
    • Language.with_constraints()
    • Language.with_default_file_extension()
    • Language.with_name()
    • Language.with_supported_features()
  • LanguageConstraints
    • LanguageConstraints.Builder
      • LanguageConstraints.Builder.build()
      • LanguageConstraints.Builder.float_types()
      • LanguageConstraints.Builder.integer_types()
      • LanguageConstraints.Builder.literal_variants()
      • LanguageConstraints.Builder.term_variants()
      • LanguageConstraints.Builder.type_variants()
      • LanguageConstraints.Builder.types()
    • LanguageConstraints.FLOAT_TYPES
    • LanguageConstraints.INTEGER_TYPES
    • LanguageConstraints.LITERAL_VARIANTS
    • LanguageConstraints.TERM_VARIANTS
    • LanguageConstraints.TYPES
    • LanguageConstraints.TYPE_
    • LanguageConstraints.TYPE_VARIANTS
    • LanguageConstraints.builder()
    • LanguageConstraints.float_types
    • LanguageConstraints.integer_types
    • LanguageConstraints.literal_variants
    • LanguageConstraints.term_variants
    • LanguageConstraints.type_variants
    • LanguageConstraints.types
    • LanguageConstraints.with_float_types()
    • LanguageConstraints.with_integer_types()
    • LanguageConstraints.with_literal_variants()
    • LanguageConstraints.with_term_variants()
    • LanguageConstraints.with_type_variants()
    • LanguageConstraints.with_types()
  • LanguageFeature
    • LanguageFeature.NESTED_CASE_STATEMENTS
    • LanguageFeature.NESTED_POLYMORPHIC_LET_BINDINGS
    • LanguageFeature.PARTIAL_APPLICATION
    • LanguageFeature.TYPE_
  • LanguageName
    • LanguageName.TYPE_
  • TraversalOrder
    • TraversalOrder.POST
    • TraversalOrder.PRE
    • TraversalOrder.TYPE_
• hydra.constants module
• hydra.core module
  • AnnotatedTerm
    • AnnotatedTerm.ANNOTATION
    • AnnotatedTerm.BODY
    • AnnotatedTerm.Builder
      • AnnotatedTerm.Builder.annotation()
      • AnnotatedTerm.Builder.body()
      • AnnotatedTerm.Builder.build()
    • AnnotatedTerm.TYPE_
    • AnnotatedTerm.annotation
    • AnnotatedTerm.body
    • AnnotatedTerm.builder()
    • AnnotatedTerm.with_annotation()
    • AnnotatedTerm.with_body()
  • AnnotatedType
    • AnnotatedType.ANNOTATION
    • AnnotatedType.BODY
    • AnnotatedType.Builder
      • AnnotatedType.Builder.annotation()
      • AnnotatedType.Builder.body()
      • AnnotatedType.Builder.build()
    • AnnotatedType.TYPE_
    • AnnotatedType.annotation
    • AnnotatedType.body
    • AnnotatedType.builder()
    • AnnotatedType.with_annotation()
    • AnnotatedType.with_body()
  • Application
    • Application.ARGUMENT
    • Application.Builder
      • Application.Builder.argument()
      • Application.Builder.build()
      • Application.Builder.function()
    • Application.FUNCTION
    • Application.TYPE_
    • Application.argument
    • Application.builder()
    • Application.function
    • Application.with_argument()
    • Application.with_function()
  • ApplicationType
    • ApplicationType.ARGUMENT
    • ApplicationType.Builder
      • ApplicationType.Builder.argument()
      • ApplicationType.Builder.build()
      • ApplicationType.Builder.function()
    • ApplicationType.FUNCTION
    • ApplicationType.TYPE_
    • ApplicationType.argument
    • ApplicationType.builder()
    • ApplicationType.function
    • ApplicationType.with_argument()
    • ApplicationType.with_function()
  • Binding
    • Binding.Builder
      • Binding.Builder.build()
      • Binding.Builder.name()
      • Binding.Builder.term()
      • Binding.Builder.type_scheme()
    • Binding.NAME
    • Binding.TERM
    • Binding.TYPE_
    • Binding.TYPE_SCHEME
    • Binding.builder()
    • Binding.name
    • Binding.term
    • Binding.type_scheme
    • Binding.with_name()
    • Binding.with_term()
    • Binding.with_type_scheme()
  • CaseAlternative
    • CaseAlternative.Builder
      • CaseAlternative.Builder.build()
      • CaseAlternative.Builder.handler()
      • CaseAlternative.Builder.name()
    • CaseAlternative.HANDLER
    • CaseAlternative.NAME
    • CaseAlternative.TYPE_
    • CaseAlternative.builder()
    • CaseAlternative.handler
    • CaseAlternative.name
    • CaseAlternative.with_handler()
    • CaseAlternative.with_name()
  • CaseStatement
    • CaseStatement.Builder
      • CaseStatement.Builder.build()
      • CaseStatement.Builder.cases()
      • CaseStatement.Builder.default()
      • CaseStatement.Builder.type_name()
    • CaseStatement.CASES
    • CaseStatement.DEFAULT
    • CaseStatement.TYPE_
    • CaseStatement.TYPE_NAME
    • CaseStatement.builder()
    • CaseStatement.cases
    • CaseStatement.default
    • CaseStatement.type_name
    • CaseStatement.with_cases()
    • CaseStatement.with_default()
    • CaseStatement.with_type_name()
  • EitherType
    • EitherType.Builder
      • EitherType.Builder.build()
      • EitherType.Builder.left()
      • EitherType.Builder.right()
    • EitherType.LEFT
    • EitherType.RIGHT
    • EitherType.TYPE_
    • EitherType.builder()
    • EitherType.left
    • EitherType.right
    • EitherType.with_left()
    • EitherType.with_right()
  • Field
    • Field.Builder
      • Field.Builder.build()
      • Field.Builder.name()
      • Field.Builder.term()
    • Field.NAME
    • Field.TERM
    • Field.TYPE_
    • Field.builder()
    • Field.name
    • Field.term
    • Field.with_name()
    • Field.with_term()
  • FieldType
    • FieldType.Builder
      • FieldType.Builder.build()
      • FieldType.Builder.name()
      • FieldType.Builder.type()
    • FieldType.NAME
    • FieldType.TYPE
    • FieldType.TYPE_
    • FieldType.builder()
    • FieldType.name
    • FieldType.type
    • FieldType.with_name()
    • FieldType.with_type()
  • FloatType
    • FloatType.FLOAT32
    • FloatType.FLOAT64
    • FloatType.TYPE_
  • FloatValue
    • FloatValue.FLOAT32
    • FloatValue.FLOAT64
    • FloatValue.TYPE_
  • FloatValueFloat32
  • FloatValueFloat64
  • ForallType
    • ForallType.BODY
    • ForallType.Builder
      • ForallType.Builder.body()
      • ForallType.Builder.build()
      • ForallType.Builder.parameter()
    • ForallType.PARAMETER
    • ForallType.TYPE_
    • ForallType.body
    • ForallType.builder()
    • ForallType.parameter
    • ForallType.with_body()
    • ForallType.with_parameter()
  • FunctionType
    • FunctionType.Builder
      • FunctionType.Builder.build()
      • FunctionType.Builder.codomain()
      • FunctionType.Builder.domain()
    • FunctionType.CODOMAIN
    • FunctionType.DOMAIN
    • FunctionType.TYPE_
    • FunctionType.builder()
    • FunctionType.codomain
    • FunctionType.domain
    • FunctionType.with_codomain()
    • FunctionType.with_domain()
  • Injection
    • Injection.Builder
      • Injection.Builder.build()
      • Injection.Builder.field()
      • Injection.Builder.type_name()
    • Injection.FIELD
    • Injection.TYPE_
    • Injection.TYPE_NAME
    • Injection.builder()
    • Injection.field
    • Injection.type_name
    • Injection.with_field()
    • Injection.with_type_name()
  • IntegerType
    • IntegerType.BIGINT
    • IntegerType.INT16
    • IntegerType.INT32
    • IntegerType.INT64
    • IntegerType.INT8
    • IntegerType.TYPE_
    • IntegerType.UINT16
    • IntegerType.UINT32
    • IntegerType.UINT64
    • IntegerType.UINT8
  • IntegerValue
    • IntegerValue.BIGINT
    • IntegerValue.INT16
    • IntegerValue.INT32
    • IntegerValue.INT64
    • IntegerValue.INT8
    • IntegerValue.TYPE_
    • IntegerValue.UINT16
    • IntegerValue.UINT32
    • IntegerValue.UINT64
    • IntegerValue.UINT8
  • IntegerValueBigint
  • IntegerValueInt16
  • IntegerValueInt32
  • IntegerValueInt64
  • IntegerValueInt8
  • IntegerValueUint16
  • IntegerValueUint32
  • IntegerValueUint64
  • IntegerValueUint8
  • Lambda
    • Lambda.BODY
    • Lambda.Builder
      • Lambda.Builder.body()
      • Lambda.Builder.build()
      • Lambda.Builder.domain()
      • Lambda.Builder.parameter()
    • Lambda.DOMAIN
    • Lambda.PARAMETER
    • Lambda.TYPE_
    • Lambda.body
    • Lambda.builder()
    • Lambda.domain
    • Lambda.parameter
    • Lambda.with_body()
    • Lambda.with_domain()
    • Lambda.with_parameter()
  • Let
    • Let.BINDINGS
    • Let.BODY
    • Let.Builder
      • Let.Builder.bindings()
      • Let.Builder.body()
      • Let.Builder.build()
    • Let.TYPE_
    • Let.bindings
    • Let.body
    • Let.builder()
    • Let.with_bindings()
    • Let.with_body()
  • Literal
    • Literal.BINARY
    • Literal.BOOLEAN
    • Literal.DECIMAL
    • Literal.FLOAT
    • Literal.INTEGER
    • Literal.STRING
    • Literal.TYPE_
  • LiteralBinary
  • LiteralBoolean
  • LiteralDecimal
  • LiteralFloat
  • LiteralInteger
  • LiteralString
  • LiteralType
    • LiteralType.BINARY
    • LiteralType.BOOLEAN
    • LiteralType.DECIMAL
    • LiteralType.FLOAT
    • LiteralType.INTEGER
    • LiteralType.STRING
    • LiteralType.TYPE_
  • LiteralTypeBinary
  • LiteralTypeBoolean
  • LiteralTypeDecimal
  • LiteralTypeFloat
  • LiteralTypeInteger
  • LiteralTypeString
  • MapType
    • MapType.Builder
      • MapType.Builder.build()
      • MapType.Builder.keys()
      • MapType.Builder.values()
    • MapType.KEYS
    • MapType.TYPE_
    • MapType.VALUES
    • MapType.builder()
    • MapType.keys
    • MapType.values
    • MapType.with_keys()
    • MapType.with_values()
  • Name
    • Name.TYPE_
  • PairType
    • PairType.Builder
      • PairType.Builder.build()
      • PairType.Builder.first()
      • PairType.Builder.second()
    • PairType.FIRST
    • PairType.SECOND
    • PairType.TYPE_
    • PairType.builder()
    • PairType.first
    • PairType.second
    • PairType.with_first()
    • PairType.with_second()
  • Projection
    • Projection.Builder
      • Projection.Builder.build()
      • Projection.Builder.field_name()
      • Projection.Builder.type_name()
    • Projection.FIELD_NAME
    • Projection.TYPE_
    • Projection.TYPE_NAME
    • Projection.builder()
    • Projection.field_name
    • Projection.type_name
    • Projection.with_field_name()
    • Projection.with_type_name()
  • Record
    • Record.Builder
      • Record.Builder.build()
      • Record.Builder.fields()
      • Record.Builder.type_name()
    • Record.FIELDS
    • Record.TYPE_
    • Record.TYPE_NAME
    • Record.builder()
    • Record.fields
    • Record.type_name
    • Record.with_fields()
    • Record.with_type_name()
  • Term
    • Term.ANNOTATED
    • Term.APPLICATION
    • Term.CASES
    • Term.EITHER
    • Term.INJECT
    • Term.LAMBDA
    • Term.LET
    • Term.LIST
    • Term.LITERAL
    • Term.MAP
    • Term.OPTIONAL
    • Term.PAIR
    • Term.PROJECT
    • Term.RECORD
    • Term.SET
    • Term.TYPE_
    • Term.TYPE_APPLICATION
    • Term.TYPE_LAMBDA
    • Term.UNIT
    • Term.UNWRAP
    • Term.VARIABLE
    • Term.WRAP
  • TermAnnotated
  • TermApplication
  • TermCases
  • TermEither
  • TermInject
  • TermLambda
  • TermLet
  • TermList
  • TermLiteral
  • TermMap
  • TermOptional
  • TermPair
  • TermProject
  • TermRecord
  • TermSet
  • TermTypeApplication
  • TermTypeLambda
  • TermUnit
  • TermUnwrap
  • TermVariable
  • TermWrap
  • Type
    • Type.ANNOTATED
    • Type.APPLICATION
    • Type.EFFECT
    • Type.EITHER
    • Type.FORALL
    • Type.FUNCTION
    • Type.LIST
    • Type.LITERAL
    • Type.MAP
    • Type.OPTIONAL
    • Type.PAIR
    • Type.RECORD
    • Type.SET
    • Type.TYPE_
    • Type.UNION
    • Type.UNIT
    • Type.VARIABLE
    • Type.VOID
    • Type.WRAP
  • TypeAnnotated
  • TypeApplication
  • TypeApplicationTerm
    • TypeApplicationTerm.BODY
    • TypeApplicationTerm.Builder
      • TypeApplicationTerm.Builder.body()
      • TypeApplicationTerm.Builder.build()
      • TypeApplicationTerm.Builder.type()
    • TypeApplicationTerm.TYPE
    • TypeApplicationTerm.TYPE_
    • TypeApplicationTerm.body
    • TypeApplicationTerm.builder()
    • TypeApplicationTerm.type
    • TypeApplicationTerm.with_body()
    • TypeApplicationTerm.with_type()
  • TypeClassConstraint
    • TypeClassConstraint.SIMPLE
    • TypeClassConstraint.TYPE_
  • TypeClassConstraintSimple
  • TypeEffect
  • TypeEither
  • TypeForall
  • TypeFunction
  • TypeLambda
    • TypeLambda.BODY
    • TypeLambda.Builder
      • TypeLambda.Builder.body()
      • TypeLambda.Builder.build()
      • TypeLambda.Builder.parameter()
    • TypeLambda.PARAMETER
    • TypeLambda.TYPE_
    • TypeLambda.body
    • TypeLambda.builder()
    • TypeLambda.parameter
    • TypeLambda.with_body()
    • TypeLambda.with_parameter()
  • TypeList
  • TypeLiteral
  • TypeMap
  • TypeOptional
  • TypePair
  • TypeRecord
  • TypeScheme
    • TypeScheme.BODY
    • TypeScheme.Builder
      • TypeScheme.Builder.body()
      • TypeScheme.Builder.build()
      • TypeScheme.Builder.constraints()
      • TypeScheme.Builder.variables()
    • TypeScheme.CONSTRAINTS
    • TypeScheme.TYPE_
    • TypeScheme.VARIABLES
    • TypeScheme.body
    • TypeScheme.builder()
    • TypeScheme.constraints
    • TypeScheme.variables
    • TypeScheme.with_body()
    • TypeScheme.with_constraints()
    • TypeScheme.with_variables()
  • TypeSet
  • TypeUnion
  • TypeUnit
  • TypeVariable
  • TypeVariableConstraints
    • TypeVariableConstraints.Builder
      • TypeVariableConstraints.Builder.build()
      • TypeVariableConstraints.Builder.classes()
    • TypeVariableConstraints.CLASSES
    • TypeVariableConstraints.TYPE_
    • TypeVariableConstraints.builder()
    • TypeVariableConstraints.classes
    • TypeVariableConstraints.with_classes()
  • TypeVoid
  • TypeWrap
  • WrappedTerm
    • WrappedTerm.BODY
    • WrappedTerm.Builder
      • WrappedTerm.Builder.body()
      • WrappedTerm.Builder.build()
      • WrappedTerm.Builder.type_name()
    • WrappedTerm.TYPE_
    • WrappedTerm.TYPE_NAME
    • WrappedTerm.body
    • WrappedTerm.builder()
    • WrappedTerm.type_name
    • WrappedTerm.with_body()
    • WrappedTerm.with_type_name()
• hydra.decoding module
  • collect_forall_variables()
  • collect_ord_constrained_variables()
  • collect_type_variables()
  • collect_type_variables_from_type()
  • decode_binding()
  • decode_binding_name()
  • decode_either_type()
  • decode_forall_type()
  • decode_list_type()
  • decode_literal_type()
  • decode_map_type()
  • decode_maybe_type()
  • decode_module()
  • decode_module_name()
  • decode_pair_type()
  • decode_record_type()
  • decode_record_type_impl()
  • decode_record_type_named()
  • decode_set_type()
  • decode_type()
  • decode_type_named()
  • decode_union_type()
  • decode_union_type_named()
  • decode_wrapped_type()
  • decode_wrapped_type_named()
  • decoder_full_result_type()
  • decoder_full_result_type_named()
  • decoder_result_type()
  • decoder_type()
  • decoder_type_named()
  • decoder_type_scheme()
  • decoder_type_scheme_named()
  • filter_type_bindings()
  • is_decodable_binding()
  • prepend_forall_decoders()
• hydra.dependencies module
  • definitions_with_dependencies()
  • flatten_let_terms()
  • inline_type()
  • is_lambda()
  • lift_lambda_above_let()
  • prune_let()
  • replace_typedefs()
  • simplify_term()
  • term_dependency_names()
  • to_short_names()
  • topological_sort_binding_map()
  • topological_sort_bindings()
  • topological_sort_type_definitions()
  • type_dependency_names()
  • type_names_in_type()
• hydra.differentiation module
  • differentiate_binary()
  • differentiate_function()
  • differentiate_term()
  • gradient()
  • primitive_derivative()
• hydra.docs module
  • DocSegment
    • DocSegment.REF
    • DocSegment.TEXT
    • DocSegment.TYPE_
  • DocSegmentRef
  • DocSegmentText
• hydra.dsls module
  • collect_forall_vars()
  • deduplicate_bindings()
  • dsl_binding_name()
  • dsl_definition_name()
  • dsl_module()
  • dsl_module_name()
  • dsl_signature_type_scheme()
  • dsl_type_scheme()
  • filter_type_bindings()
  • generate_bindings_for_type()
  • generate_parametric_ref_builders()
  • generate_record_accessor()
  • generate_record_constructor()
  • generate_record_with_updater()
  • generate_ref_bindings()
  • generate_signature_ref()
  • generate_type_name_token()
  • generate_union_injector()
  • generate_wrapped_type_accessors()
  • is_dsl_eligible_binding()
  • nominal_result_type()
  • signature_is_void_free()
  • type_is_void_free()
• hydra.encoding module
  • encode_binding()
  • encode_binding_name()
  • encode_either_type()
  • encode_field_value()
  • encode_float_value()
  • encode_forall_type()
  • encode_injection()
  • encode_integer_value()
  • encode_list_type()
  • encode_literal_type()
  • encode_map_type()
  • encode_module()
  • encode_module_name()
  • encode_name()
  • encode_optional_type()
  • encode_pair_type()
  • encode_record_type()
  • encode_record_type_named()
  • encode_set_type()
  • encode_type()
  • encode_type_named()
  • encode_union_type()
  • encode_union_type_named()
  • encode_wrapped_type()
  • encode_wrapped_type_named()
  • encoder_collect_forall_variables()
  • encoder_collect_ord_vars()
  • encoder_collect_type_vars_from_type()
  • encoder_full_result_type()
  • encoder_full_result_type_named()
  • encoder_type()
  • encoder_type_named()
  • encoder_type_scheme()
  • encoder_type_scheme_named()
  • filter_type_bindings()
  • is_encodable_binding()
  • is_unit_type()
  • prepend_forall_encoders()
• hydra.environment module
  • definition_as_type_application_term()
  • graph_as_let()
  • graph_as_term()
  • graph_as_types()
  • partition_definitions()
  • reorder_defs()
  • schema_graph_to_typing_environment()
  • term_as_bindings()
  • types_to_definitions()
  • with_lambda_context()
  • with_let_context()
  • with_type_lambda_context()
• hydra.errors module
  • DecodingError
    • DecodingError.TYPE_
  • Error
    • Error.CHECKING
    • Error.DECODING
    • Error.DUPLICATE_BINDING
    • Error.DUPLICATE_FIELD
    • Error.EXTRACTION
    • Error.INFERENCE
    • Error.INVALID_LITERAL
    • Error.OTHER
    • Error.RESOLUTION
    • Error.TYPE_
    • Error.UNDEFINED_FIELD
    • Error.UNDEFINED_TERM_VARIABLE
    • Error.UNEXPECTED_TERM_VARIANT
    • Error.UNEXPECTED_TYPE_VARIANT
    • Error.UNIFICATION
    • Error.UNTYPED_TERM_VARIABLE
  • ErrorChecking
  • ErrorDecoding
  • ErrorDuplicateBinding
  • ErrorDuplicateField
  • ErrorExtraction
  • ErrorInference
  • ErrorInvalidLiteral
  • ErrorOther
  • ErrorResolution
  • ErrorUndefinedField
  • ErrorUndefinedTermVariable
  • ErrorUnexpectedTermVariant
  • ErrorUnexpectedTypeVariant
  • ErrorUnification
  • ErrorUntypedTermVariable
  • ExtractionError
    • ExtractionError.EMPTY_LIST
    • ExtractionError.MULTIPLE_BINDINGS
    • ExtractionError.MULTIPLE_FIELDS
    • ExtractionError.NOT_ENOUGH_CASES
    • ExtractionError.NO_MATCHING_FIELD
    • ExtractionError.NO_SUCH_BINDING
    • ExtractionError.TYPE_
    • ExtractionError.UNEXPECTED_SHAPE
  • ExtractionErrorEmptyList
  • ExtractionErrorMultipleBindings
  • ExtractionErrorMultipleFields
  • ExtractionErrorNoMatchingField
  • ExtractionErrorNoSuchBinding
  • ExtractionErrorNotEnoughCases
  • ExtractionErrorUnexpectedShape
  • InferenceError
    • InferenceError.CHECKING
    • InferenceError.OTHER
    • InferenceError.TYPE_
    • InferenceError.UNIFICATION
  • InferenceErrorChecking
  • InferenceErrorOther
  • InferenceErrorUnification
  • MultipleBindingsError
    • MultipleBindingsError.Builder
      • MultipleBindingsError.Builder.build()
      • MultipleBindingsError.Builder.name()
    • MultipleBindingsError.NAME
    • MultipleBindingsError.TYPE_
    • MultipleBindingsError.builder()
    • MultipleBindingsError.name
    • MultipleBindingsError.with_name()
  • MultipleFieldsError
    • MultipleFieldsError.Builder
      • MultipleFieldsError.Builder.build()
      • MultipleFieldsError.Builder.field_name()
    • MultipleFieldsError.FIELD_NAME
    • MultipleFieldsError.TYPE_
    • MultipleFieldsError.builder()
    • MultipleFieldsError.field_name
    • MultipleFieldsError.with_field_name()
  • NoMatchingFieldError
    • NoMatchingFieldError.Builder
      • NoMatchingFieldError.Builder.build()
      • NoMatchingFieldError.Builder.field_name()
    • NoMatchingFieldError.FIELD_NAME
    • NoMatchingFieldError.TYPE_
    • NoMatchingFieldError.builder()
    • NoMatchingFieldError.field_name
    • NoMatchingFieldError.with_field_name()
  • NoSuchBindingError
    • NoSuchBindingError.Builder
      • NoSuchBindingError.Builder.build()
      • NoSuchBindingError.Builder.name()
    • NoSuchBindingError.NAME
    • NoSuchBindingError.TYPE_
    • NoSuchBindingError.builder()
    • NoSuchBindingError.name
    • NoSuchBindingError.with_name()
  • NoSuchPrimitiveError
    • NoSuchPrimitiveError.Builder
      • NoSuchPrimitiveError.Builder.build()
      • NoSuchPrimitiveError.Builder.name()
    • NoSuchPrimitiveError.NAME
    • NoSuchPrimitiveError.TYPE_
    • NoSuchPrimitiveError.builder()
    • NoSuchPrimitiveError.name
    • NoSuchPrimitiveError.with_name()
  • OtherError
    • OtherError.TYPE_
  • OtherInferenceError
    • OtherInferenceError.Builder
      • OtherInferenceError.Builder.build()
      • OtherInferenceError.Builder.message()
      • OtherInferenceError.Builder.path()
    • OtherInferenceError.MESSAGE
    • OtherInferenceError.PATH
    • OtherInferenceError.TYPE_
    • OtherInferenceError.builder()
    • OtherInferenceError.message
    • OtherInferenceError.path
    • OtherInferenceError.with_message()
    • OtherInferenceError.with_path()
  • OtherResolutionError
    • OtherResolutionError.TYPE_
  • ResolutionError
    • ResolutionError.NO_MATCHING_FIELD
    • ResolutionError.NO_SUCH_BINDING
    • ResolutionError.NO_SUCH_PRIMITIVE
    • ResolutionError.OTHER
    • ResolutionError.TYPE_
    • ResolutionError.UNEXPECTED_SHAPE
  • ResolutionErrorNoMatchingField
  • ResolutionErrorNoSuchBinding
  • ResolutionErrorNoSuchPrimitive
  • ResolutionErrorOther
  • ResolutionErrorUnexpectedShape
  • UnexpectedShapeError
    • UnexpectedShapeError.ACTUAL
    • UnexpectedShapeError.Builder
      • UnexpectedShapeError.Builder.actual()
      • UnexpectedShapeError.Builder.build()
      • UnexpectedShapeError.Builder.expected()
    • UnexpectedShapeError.EXPECTED
    • UnexpectedShapeError.TYPE_
    • UnexpectedShapeError.actual
    • UnexpectedShapeError.builder()
    • UnexpectedShapeError.expected
    • UnexpectedShapeError.with_actual()
    • UnexpectedShapeError.with_expected()
  • UnificationError
    • UnificationError.Builder
      • UnificationError.Builder.build()
      • UnificationError.Builder.left_type()
      • UnificationError.Builder.message()
      • UnificationError.Builder.right_type()
    • UnificationError.LEFT_TYPE
    • UnificationError.MESSAGE
    • UnificationError.RIGHT_TYPE
    • UnificationError.TYPE_
    • UnificationError.builder()
    • UnificationError.left_type
    • UnificationError.message
    • UnificationError.right_type
    • UnificationError.with_left_type()
    • UnificationError.with_message()
    • UnificationError.with_right_type()
  • UnificationInferenceError
    • UnificationInferenceError.Builder
      • UnificationInferenceError.Builder.build()
      • UnificationInferenceError.Builder.cause()
      • UnificationInferenceError.Builder.path()
    • UnificationInferenceError.CAUSE
    • UnificationInferenceError.PATH
    • UnificationInferenceError.TYPE_
    • UnificationInferenceError.builder()
    • UnificationInferenceError.cause
    • UnificationInferenceError.path
    • UnificationInferenceError.with_cause()
    • UnificationInferenceError.with_path()
• hydra.file module
  • FileExtension
    • FileExtension.TYPE_
  • FilePath
    • FilePath.TYPE_
  • FileStatus
    • FileStatus.ACCESS_TIME
    • FileStatus.Builder
      • FileStatus.Builder.access_time()
      • FileStatus.Builder.build()
      • FileStatus.Builder.file_type()
      • FileStatus.Builder.modification_time()
      • FileStatus.Builder.size()
      • FileStatus.Builder.status_change_time()
    • FileStatus.FILE_TYPE
    • FileStatus.MODIFICATION_TIME
    • FileStatus.SIZE
    • FileStatus.STATUS_CHANGE_TIME
    • FileStatus.TYPE_
    • FileStatus.access_time
    • FileStatus.builder()
    • FileStatus.file_type
    • FileStatus.modification_time
    • FileStatus.size
    • FileStatus.status_change_time
    • FileStatus.with_access_time()
    • FileStatus.with_file_type()
    • FileStatus.with_modification_time()
    • FileStatus.with_size()
    • FileStatus.with_status_change_time()
  • FileType
    • FileType.BLOCK
    • FileType.CHARACTER
    • FileType.DIRECTORY
    • FileType.FIFO
    • FileType.LINK
    • FileType.REGULAR
    • FileType.SOCKET
    • FileType.TYPE_
• hydra.formatting module
  • capitalize()
  • convert_case()
  • convert_case_camel_or_underscore_to_lower_snake()
  • convert_case_camel_to_lower_snake()
  • convert_case_camel_to_upper_snake()
  • convert_case_pascal_to_upper_snake()
  • decapitalize()
  • escape_with_underscore()
  • indent_lines()
  • java_style_comment()
  • lines()
  • map_first_letter()
  • non_alnum_to_underscores()
  • normalize_comment()
  • sanitize_with_underscores()
  • show_list()
  • strip_leading_and_trailing_whitespace()
  • unlines()
  • with_character_aliases()
  • wrap_line()
• hydra.graph module
  • Graph
    • Graph.BOUND_TERMS
    • Graph.BOUND_TYPES
    • Graph.Builder
      • Graph.Builder.bound_terms()
      • Graph.Builder.bound_types()
      • Graph.Builder.build()
      • Graph.Builder.class_constraints()
      • Graph.Builder.lambda_variables()
      • Graph.Builder.metadata()
      • Graph.Builder.primitives()
      • Graph.Builder.schema_types()
      • Graph.Builder.type_variables()
    • Graph.CLASS_CONSTRAINTS
    • Graph.LAMBDA_VARIABLES
    • Graph.METADATA
    • Graph.PRIMITIVES
    • Graph.SCHEMA_TYPES
    • Graph.TYPE_
    • Graph.TYPE_VARIABLES
    • Graph.bound_terms
    • Graph.bound_types
    • Graph.builder()
    • Graph.class_constraints
    • Graph.lambda_variables
    • Graph.metadata
    • Graph.primitives
    • Graph.schema_types
    • Graph.type_variables
    • Graph.with_bound_terms()
    • Graph.with_bound_types()
    • Graph.with_class_constraints()
    • Graph.with_lambda_variables()
    • Graph.with_metadata()
    • Graph.with_primitives()
    • Graph.with_schema_types()
    • Graph.with_type_variables()
  • Library
    • Library.Builder
      • Library.Builder.build()
      • Library.Builder.name()
      • Library.Builder.prefix()
      • Library.Builder.primitives()
    • Library.NAME
    • Library.PREFIX
    • Library.PRIMITIVES
    • Library.TYPE_
    • Library.builder()
    • Library.name
    • Library.prefix
    • Library.primitives
    • Library.with_name()
    • Library.with_prefix()
    • Library.with_primitives()
  • Primitive
    • Primitive.Builder
      • Primitive.Builder.build()
      • Primitive.Builder.definition()
      • Primitive.Builder.implementation()
    • Primitive.DEFINITION
    • Primitive.IMPLEMENTATION
    • Primitive.TYPE_
    • Primitive.builder()
    • Primitive.definition
    • Primitive.implementation
    • Primitive.with_definition()
    • Primitive.with_implementation()
  • TermCoder
    • TermCoder.Builder
      • TermCoder.Builder.build()
      • TermCoder.Builder.decode()
      • TermCoder.Builder.encode()
      • TermCoder.Builder.type()
    • TermCoder.DECODE
    • TermCoder.ENCODE
    • TermCoder.TYPE
    • TermCoder.TYPE_
    • TermCoder.builder()
    • TermCoder.decode
    • TermCoder.encode
    • TermCoder.type
    • TermCoder.with_decode()
    • TermCoder.with_encode()
    • TermCoder.with_type()
• hydra.hoisting module
  • augment_bindings_with_new_free_vars()
  • binding_is_polymorphic()
  • binding_uses_context_type_vars()
  • count_var_occurrences()
  • hoist_all_let_bindings()
  • hoist_case_statements()
  • hoist_case_statements_in_graph()
  • hoist_let_bindings_with_context()
  • hoist_let_bindings_with_predicate()
  • hoist_polymorphic_let_bindings()
  • hoist_subterms()
  • is_application_function()
  • is_lambda_body()
  • is_union_elimination()
  • is_union_elimination_application()
  • normalize_path_for_hoisting()
  • should_hoist_all()
  • should_hoist_case_statement()
  • should_hoist_polymorphic()
  • update_hoist_state()
• hydra.inference module
  • at_or_fail()
  • bind_constraints()
  • bind_unbound_type_variables()
  • build_type_application_term()
  • discharge_class_constraints()
  • extend_context()
  • finalize_inferred_term()
  • for_inferred_term()
  • free_variables_in_context()
  • fresh_variable_type()
  • generalize()
  • head_or_fail()
  • infer_graph_types()
  • infer_in_graph_context()
  • infer_many()
  • infer_type_of()
  • infer_type_of_annotated_term()
  • infer_type_of_application()
  • infer_type_of_case_statement()
  • infer_type_of_collection()
  • infer_type_of_either()
  • infer_type_of_injection()
  • infer_type_of_lambda()
  • infer_type_of_let()
  • infer_type_of_let_normalized()
  • infer_type_of_list()
  • infer_type_of_literal()
  • infer_type_of_map()
  • infer_type_of_optional()
  • infer_type_of_pair()
  • infer_type_of_projection()
  • infer_type_of_record()
  • infer_type_of_set()
  • infer_type_of_term()
  • infer_type_of_type_application()
  • infer_type_of_type_lambda()
  • infer_type_of_unit()
  • infer_type_of_unwrap()
  • infer_type_of_variable()
  • infer_type_of_wrapped_term()
  • infer_types_of_temporary_bindings()
  • is_unbound()
  • map_constraints()
  • merge_class_constraints()
  • show_inference_result()
  • yield_()
  • yield_checked()
  • yield_checked_with_constraints()
  • yield_with_constraints()
• hydra.languages module
  • hydra_language()
• hydra.lexical module
  • build_graph()
  • choose_unique_name()
  • dereference_schema_type()
  • dereference_variable()
  • elements_to_graph()
  • empty_graph()
  • empty_inference_context()
  • fields_of()
  • get_field()
  • graph_to_bindings()
  • graph_with_primitives()
  • lookup_binding()
  • lookup_primitive()
  • lookup_term()
  • match_enum()
  • match_record()
  • match_union()
  • match_unit_field()
  • require_binding()
  • require_primitive()
  • require_primitive_type()
  • require_term()
  • resolve_term()
  • strip_and_dereference_term()
  • strip_and_dereference_term_either()
• hydra.literals module
  • bigint_to_integer_value()
  • integer_value_to_bigint()
• hydra.names module
  • choose_unique_label()
  • compact_name()
  • derived_binding_name()
  • derived_definition_name()
  • derived_module_name()
  • fresh_name()
  • fresh_names()
  • local_name_of()
  • module_name_of()
  • module_name_to_file_path()
  • name_to_file_path()
  • normal_type_variable()
  • push_subterm_step()
  • qname()
  • qualify_name()
  • restore_trace()
  • unqualify_name()
• hydra.packaging module
  • Definition
    • Definition.PRIMITIVE
    • Definition.TERM
    • Definition.TYPE
    • Definition.TYPE_
  • DefinitionPrimitive
  • DefinitionReference
    • DefinitionReference.PRIMITIVE
    • DefinitionReference.TERM
    • DefinitionReference.TYPE
    • DefinitionReference.TYPE_
  • DefinitionReferencePrimitive
  • DefinitionReferenceTerm
  • DefinitionReferenceType
  • DefinitionTerm
  • DefinitionType
  • DependencyScope
    • DependencyScope.API
    • DependencyScope.RUNTIME
    • DependencyScope.TEST
    • DependencyScope.TOOL
    • DependencyScope.TYPE_
  • EntityMetadata
    • EntityMetadata.Builder
      • EntityMetadata.Builder.build()
      • EntityMetadata.Builder.comments()
      • EntityMetadata.Builder.description()
      • EntityMetadata.Builder.lifecycle()
      • EntityMetadata.Builder.see_also()
    • EntityMetadata.COMMENTS
    • EntityMetadata.DESCRIPTION
    • EntityMetadata.LIFECYCLE
    • EntityMetadata.SEE_ALSO
    • EntityMetadata.TYPE_
    • EntityMetadata.builder()
    • EntityMetadata.comments
    • EntityMetadata.description
    • EntityMetadata.lifecycle
    • EntityMetadata.see_also
    • EntityMetadata.with_comments()
    • EntityMetadata.with_description()
    • EntityMetadata.with_lifecycle()
    • EntityMetadata.with_see_also()
  • EntityReference
    • EntityReference.DEFINITION
    • EntityReference.MODULE
    • EntityReference.PACKAGE
    • EntityReference.TERM_EXPR
    • EntityReference.TYPE_
    • EntityReference.TYPE_EXPR
  • EntityReferenceDefinition
  • EntityReferenceModule
  • EntityReferencePackage
  • EntityReferenceTermExpr
  • EntityReferenceTypeExpr
  • LifecycleInfo
    • LifecycleInfo.AVAILABLE_SINCE
    • LifecycleInfo.Builder
      • LifecycleInfo.Builder.available_since()
      • LifecycleInfo.Builder.build()
      • LifecycleInfo.Builder.deprecated_since()
    • LifecycleInfo.DEPRECATED_SINCE
    • LifecycleInfo.TYPE_
    • LifecycleInfo.available_since
    • LifecycleInfo.builder()
    • LifecycleInfo.deprecated_since
    • LifecycleInfo.with_available_since()
    • LifecycleInfo.with_deprecated_since()
  • Module
    • Module.Builder
      • Module.Builder.build()
      • Module.Builder.definitions()
      • Module.Builder.dependencies()
      • Module.Builder.metadata()
      • Module.Builder.name()
    • Module.DEFINITIONS
    • Module.DEPENDENCIES
    • Module.METADATA
    • Module.NAME
    • Module.TYPE_
    • Module.builder()
    • Module.definitions
    • Module.dependencies
    • Module.metadata
    • Module.name
    • Module.with_definitions()
    • Module.with_dependencies()
    • Module.with_metadata()
    • Module.with_name()
  • ModuleDependency
    • ModuleDependency.Builder
      • ModuleDependency.Builder.build()
      • ModuleDependency.Builder.module()
      • ModuleDependency.Builder.package()
    • ModuleDependency.MODULE
    • ModuleDependency.PACKAGE
    • ModuleDependency.TYPE_
    • ModuleDependency.builder()
    • ModuleDependency.module
    • ModuleDependency.package
    • ModuleDependency.with_module()
    • ModuleDependency.with_package()
  • ModuleName
    • ModuleName.TYPE_
  • Package
    • Package.Builder
      • Package.Builder.build()
      • Package.Builder.dependencies()
      • Package.Builder.metadata()
      • Package.Builder.modules()
      • Package.Builder.name()
    • Package.DEPENDENCIES
    • Package.METADATA
    • Package.MODULES
    • Package.NAME
    • Package.TYPE_
    • Package.builder()
    • Package.dependencies
    • Package.metadata
    • Package.modules
    • Package.name
    • Package.with_dependencies()
    • Package.with_metadata()
    • Package.with_modules()
    • Package.with_name()
  • PackageDependency
    • PackageDependency.Builder
      • PackageDependency.Builder.build()
      • PackageDependency.Builder.name()
      • PackageDependency.Builder.scope()
      • PackageDependency.Builder.version()
    • PackageDependency.NAME
    • PackageDependency.SCOPE
    • PackageDependency.TYPE_
    • PackageDependency.VERSION
    • PackageDependency.builder()
    • PackageDependency.name
    • PackageDependency.scope
    • PackageDependency.version
    • PackageDependency.with_name()
    • PackageDependency.with_scope()
    • PackageDependency.with_version()
  • PackageName
    • PackageName.TYPE_
  • PrimitiveDefinition
    • PrimitiveDefinition.Builder
      • PrimitiveDefinition.Builder.build()
      • PrimitiveDefinition.Builder.default_implementation()
      • PrimitiveDefinition.Builder.is_pure()
      • PrimitiveDefinition.Builder.is_total()
      • PrimitiveDefinition.Builder.metadata()
      • PrimitiveDefinition.Builder.name()
      • PrimitiveDefinition.Builder.signature()
    • PrimitiveDefinition.DEFAULT_IMPLEMENTATION
    • PrimitiveDefinition.IS_PURE
    • PrimitiveDefinition.IS_TOTAL
    • PrimitiveDefinition.METADATA
    • PrimitiveDefinition.NAME
    • PrimitiveDefinition.SIGNATURE
    • PrimitiveDefinition.TYPE_
    • PrimitiveDefinition.builder()
    • PrimitiveDefinition.default_implementation
    • PrimitiveDefinition.is_pure
    • PrimitiveDefinition.is_total
    • PrimitiveDefinition.metadata
    • PrimitiveDefinition.name
    • PrimitiveDefinition.signature
    • PrimitiveDefinition.with_default_implementation()
    • PrimitiveDefinition.with_is_pure()
    • PrimitiveDefinition.with_is_total()
    • PrimitiveDefinition.with_metadata()
    • PrimitiveDefinition.with_name()
    • PrimitiveDefinition.with_signature()
  • TermDefinition
    • TermDefinition.BODY
    • TermDefinition.Builder
      • TermDefinition.Builder.body()
      • TermDefinition.Builder.build()
      • TermDefinition.Builder.metadata()
      • TermDefinition.Builder.name()
      • TermDefinition.Builder.signature()
    • TermDefinition.METADATA
    • TermDefinition.NAME
    • TermDefinition.SIGNATURE
    • TermDefinition.TYPE_
    • TermDefinition.body
    • TermDefinition.builder()
    • TermDefinition.metadata
    • TermDefinition.name
    • TermDefinition.signature
    • TermDefinition.with_body()
    • TermDefinition.with_metadata()
    • TermDefinition.with_name()
    • TermDefinition.with_signature()
  • TypeDefinition
    • TypeDefinition.BODY
    • TypeDefinition.Builder
      • TypeDefinition.Builder.body()
      • TypeDefinition.Builder.build()
      • TypeDefinition.Builder.metadata()
      • TypeDefinition.Builder.name()
    • TypeDefinition.METADATA
    • TypeDefinition.NAME
    • TypeDefinition.TYPE_
    • TypeDefinition.body
    • TypeDefinition.builder()
    • TypeDefinition.metadata
    • TypeDefinition.name
    • TypeDefinition.with_body()
    • TypeDefinition.with_metadata()
    • TypeDefinition.with_name()
  • Version
    • Version.TYPE_
  • VersionRange
    • VersionRange.Builder
      • VersionRange.Builder.build()
      • VersionRange.Builder.lower_inclusive()
      • VersionRange.Builder.upper_exclusive()
    • VersionRange.LOWER_INCLUSIVE
    • VersionRange.TYPE_
    • VersionRange.UPPER_EXCLUSIVE
    • VersionRange.builder()
    • VersionRange.lower_inclusive
    • VersionRange.upper_exclusive
    • VersionRange.with_lower_inclusive()
    • VersionRange.with_upper_exclusive()
  • VersionSpecifier
    • VersionSpecifier.ANY
    • VersionSpecifier.AT_LEAST
    • VersionSpecifier.EXACT
    • VersionSpecifier.RANGE
    • VersionSpecifier.TYPE_
  • VersionSpecifierAny
  • VersionSpecifierAtLeast
  • VersionSpecifierExact
  • VersionSpecifierRange
• hydra.parsers module
  • alt()
  • any_char()
  • apply()
  • between()
  • bind()
  • char()
  • choice()
  • eof()
  • fail()
  • lazy()
  • many()
  • many_loop()
  • map()
  • optional()
  • pure()
  • run_parser()
  • satisfy()
  • sep_by()
  • sep_by1()
  • some()
  • string()
• hydra.parsing module
  • ParseError
    • ParseError.Builder
      • ParseError.Builder.build()
      • ParseError.Builder.message()
      • ParseError.Builder.remainder()
    • ParseError.MESSAGE
    • ParseError.REMAINDER
    • ParseError.TYPE_
    • ParseError.builder()
    • ParseError.message
    • ParseError.remainder
    • ParseError.with_message()
    • ParseError.with_remainder()
  • ParseResult
    • ParseResult.FAILURE
    • ParseResult.SUCCESS
    • ParseResult.TYPE_
  • ParseResultFailure
  • ParseResultSuccess
  • ParseSuccess
    • ParseSuccess.Builder
      • ParseSuccess.Builder.build()
      • ParseSuccess.Builder.remainder()
      • ParseSuccess.Builder.value()
    • ParseSuccess.REMAINDER
    • ParseSuccess.TYPE_
    • ParseSuccess.VALUE
    • ParseSuccess.builder()
    • ParseSuccess.remainder
    • ParseSuccess.value
    • ParseSuccess.with_remainder()
    • ParseSuccess.with_value()
  • Parser
    • Parser.TYPE_
• hydra.paths module
  • SubtermAttribute
    • SubtermAttribute.Builder
      • SubtermAttribute.Builder.build()
      • SubtermAttribute.Builder.path()
      • SubtermAttribute.Builder.target()
    • SubtermAttribute.PATH
    • SubtermAttribute.TARGET
    • SubtermAttribute.TYPE_
    • SubtermAttribute.builder()
    • SubtermAttribute.path
    • SubtermAttribute.target
    • SubtermAttribute.with_path()
    • SubtermAttribute.with_target()
  • SubtermEdge
    • SubtermEdge.Builder
      • SubtermEdge.Builder.build()
      • SubtermEdge.Builder.path()
      • SubtermEdge.Builder.target()
    • SubtermEdge.PATH
    • SubtermEdge.TARGET
    • SubtermEdge.TYPE_
    • SubtermEdge.builder()
    • SubtermEdge.path
    • SubtermEdge.target
    • SubtermEdge.with_path()
    • SubtermEdge.with_target()
  • SubtermGraph
    • SubtermGraph.Builder
      • SubtermGraph.Builder.build()
      • SubtermGraph.Builder.nodes()
    • SubtermGraph.NODES
    • SubtermGraph.TYPE_
    • SubtermGraph.builder()
    • SubtermGraph.nodes
    • SubtermGraph.with_nodes()
  • SubtermLink
    • SubtermLink.ATTRIBUTE
    • SubtermLink.EDGE
    • SubtermLink.PROPERTY
    • SubtermLink.TYPE_
  • SubtermLinkAttribute
  • SubtermLinkEdge
  • SubtermLinkProperty
  • SubtermNode
    • SubtermNode.Builder
      • SubtermNode.Builder.build()
      • SubtermNode.Builder.links()
      • SubtermNode.Builder.name()
      • SubtermNode.Builder.type()
    • SubtermNode.LINKS
    • SubtermNode.NAME
    • SubtermNode.TYPE
    • SubtermNode.TYPE_
    • SubtermNode.builder()
    • SubtermNode.links
    • SubtermNode.name
    • SubtermNode.type
    • SubtermNode.with_links()
    • SubtermNode.with_name()
    • SubtermNode.with_type()
  • SubtermPath
    • SubtermPath.TYPE_
  • SubtermProperty
    • SubtermProperty.Builder
      • SubtermProperty.Builder.build()
      • SubtermProperty.Builder.path()
      • SubtermProperty.Builder.target()
    • SubtermProperty.PATH
    • SubtermProperty.TARGET
    • SubtermProperty.TYPE_
    • SubtermProperty.builder()
    • SubtermProperty.path
    • SubtermProperty.target
    • SubtermProperty.with_path()
    • SubtermProperty.with_target()
  • SubtermStep
    • SubtermStep.ANNOTATED_ANNOTATION
    • SubtermStep.ANNOTATED_BODY
    • SubtermStep.APPLICATION_ARGUMENT
    • SubtermStep.APPLICATION_FUNCTION
    • SubtermStep.CASES_CASE
    • SubtermStep.CASES_DEFAULT
    • SubtermStep.EITHER_LEFT
    • SubtermStep.EITHER_RIGHT
    • SubtermStep.INJECT_FIELD
    • SubtermStep.LAMBDA_BODY
    • SubtermStep.LET_BINDING
    • SubtermStep.LET_BODY
    • SubtermStep.LIST_ELEMENT
    • SubtermStep.MAP_KEY
    • SubtermStep.MAP_VALUE
    • SubtermStep.OPTIONAL_GIVEN
    • SubtermStep.PAIR_FIRST
    • SubtermStep.PAIR_SECOND
    • SubtermStep.RECORD_FIELD
    • SubtermStep.SET_ELEMENT
    • SubtermStep.TYPE_
    • SubtermStep.TYPE_APPLICATION_BODY
    • SubtermStep.TYPE_LAMBDA_BODY
    • SubtermStep.WRAP_BODY
  • SubtermStepAnnotatedAnnotation
  • SubtermStepAnnotatedBody
  • SubtermStepApplicationArgument
  • SubtermStepApplicationFunction
  • SubtermStepCasesCase
  • SubtermStepCasesDefault
  • SubtermStepEitherLeft
  • SubtermStepEitherRight
  • SubtermStepInjectField
  • SubtermStepLambdaBody
  • SubtermStepLetBinding
  • SubtermStepLetBody
  • SubtermStepListElement
  • SubtermStepMapKey
  • SubtermStepMapValue
  • SubtermStepOptionalGiven
  • SubtermStepPairFirst
  • SubtermStepPairSecond
  • SubtermStepRecordField
  • SubtermStepSetElement
  • SubtermStepTypeApplicationBody
  • SubtermStepTypeLambdaBody
  • SubtermStepWrapBody
  • SubtypeAttribute
    • SubtypeAttribute.Builder
      • SubtypeAttribute.Builder.build()
      • SubtypeAttribute.Builder.path()
      • SubtypeAttribute.Builder.target()
    • SubtypeAttribute.PATH
    • SubtypeAttribute.TARGET
    • SubtypeAttribute.TYPE_
    • SubtypeAttribute.builder()
    • SubtypeAttribute.path
    • SubtypeAttribute.target
    • SubtypeAttribute.with_path()
    • SubtypeAttribute.with_target()
  • SubtypeEdge
    • SubtypeEdge.Builder
      • SubtypeEdge.Builder.build()
      • SubtypeEdge.Builder.path()
      • SubtypeEdge.Builder.target()
    • SubtypeEdge.PATH
    • SubtypeEdge.TARGET
    • SubtypeEdge.TYPE_
    • SubtypeEdge.builder()
    • SubtypeEdge.path
    • SubtypeEdge.target
    • SubtypeEdge.with_path()
    • SubtypeEdge.with_target()
  • SubtypeGraph
    • SubtypeGraph.Builder
      • SubtypeGraph.Builder.build()
      • SubtypeGraph.Builder.nodes()
    • SubtypeGraph.NODES
    • SubtypeGraph.TYPE_
    • SubtypeGraph.builder()
    • SubtypeGraph.nodes
    • SubtypeGraph.with_nodes()
  • SubtypeLink
    • SubtypeLink.ATTRIBUTE
    • SubtypeLink.EDGE
    • SubtypeLink.PROPERTY
    • SubtypeLink.TYPE_
  • SubtypeLinkAttribute
  • SubtypeLinkEdge
  • SubtypeLinkProperty
  • SubtypeNode
    • SubtypeNode.Builder
      • SubtypeNode.Builder.build()
      • SubtypeNode.Builder.links()
      • SubtypeNode.Builder.name()
    • SubtypeNode.LINKS
    • SubtypeNode.NAME
    • SubtypeNode.TYPE_
    • SubtypeNode.builder()
    • SubtypeNode.links
    • SubtypeNode.name
    • SubtypeNode.with_links()
    • SubtypeNode.with_name()
  • SubtypePath
    • SubtypePath.TYPE_
  • SubtypeProperty
    • SubtypeProperty.Builder
      • SubtypeProperty.Builder.build()
      • SubtypeProperty.Builder.path()
      • SubtypeProperty.Builder.target()
    • SubtypeProperty.PATH
    • SubtypeProperty.TARGET
    • SubtypeProperty.TYPE_
    • SubtypeProperty.builder()
    • SubtypeProperty.path
    • SubtypeProperty.target
    • SubtypeProperty.with_path()
    • SubtypeProperty.with_target()
  • SubtypeStep
    • SubtypeStep.ANNOTATED_BODY
    • SubtypeStep.APPLICATION_ARGUMENT
    • SubtypeStep.APPLICATION_FUNCTION
    • SubtypeStep.EFFECT_VALUE
    • SubtypeStep.EITHER_LEFT
    • SubtypeStep.EITHER_RIGHT
    • SubtypeStep.FORALL_BODY
    • SubtypeStep.FUNCTION_CODOMAIN
    • SubtypeStep.FUNCTION_DOMAIN
    • SubtypeStep.LIST_ELEMENT
    • SubtypeStep.MAP_KEYS
    • SubtypeStep.MAP_VALUES
    • SubtypeStep.OPTIONAL_ELEMENT
    • SubtypeStep.PAIR_FIRST
    • SubtypeStep.PAIR_SECOND
    • SubtypeStep.RECORD_FIELD
    • SubtypeStep.SET_ELEMENT
    • SubtypeStep.TYPE_
    • SubtypeStep.UNION_FIELD
    • SubtypeStep.WRAP_BODY
  • SubtypeStepAnnotatedBody
  • SubtypeStepApplicationArgument
  • SubtypeStepApplicationFunction
  • SubtypeStepEffectValue
  • SubtypeStepEitherLeft
  • SubtypeStepEitherRight
  • SubtypeStepForallBody
  • SubtypeStepFunctionCodomain
  • SubtypeStepFunctionDomain
  • SubtypeStepListElement
  • SubtypeStepMapKeys
  • SubtypeStepMapValues
  • SubtypeStepOptionalElement
  • SubtypeStepPairFirst
  • SubtypeStepPairSecond
  • SubtypeStepRecordField
  • SubtypeStepSetElement
  • SubtypeStepUnionField
  • SubtypeStepWrapBody
  • TermAttribute
    • TermAttribute.CASES_TYPE_NAME
    • TermAttribute.INJECT_TYPE_NAME
    • TermAttribute.LAMBDA_DOMAIN_GIVEN
    • TermAttribute.LAMBDA_PARAMETER
    • TermAttribute.LET_BINDING_TYPE_SCHEME_GIVEN
    • TermAttribute.PROJECT_FIELD_NAME
    • TermAttribute.PROJECT_TYPE_NAME
    • TermAttribute.RECORD_TYPE_NAME
    • TermAttribute.TYPE_
    • TermAttribute.TYPE_APPLICATION_TYPE
    • TermAttribute.TYPE_LAMBDA_PARAMETER
    • TermAttribute.WRAP_TYPE_NAME
  • TermAttributeCasesTypeName
  • TermAttributeInjectTypeName
  • TermAttributeLambdaDomainGiven
  • TermAttributeLambdaParameter
  • TermAttributeLetBindingTypeSchemeGiven
  • TermAttributeProjectFieldName
  • TermAttributeProjectTypeName
  • TermAttributeRecordTypeName
  • TermAttributeTypeApplicationType
  • TermAttributeTypeLambdaParameter
  • TermAttributeWrapTypeName
  • TypeAttribute
    • TypeAttribute.ANNOTATED_ANNOTATION
    • TypeAttribute.FORALL_PARAMETER
    • TypeAttribute.TYPE_
  • TypeAttributeAnnotatedAnnotation
  • TypeAttributeForallParameter
• hydra.predicates module
  • is_complex_binding()
  • is_complex_term()
  • is_complex_variable()
  • is_encoded_term()
  • is_encoded_type()
  • is_enum_row_type()
  • is_enum_type()
  • is_nominal_type()
  • is_serializable()
  • is_serializable_by_name()
  • is_serializable_type()
  • is_trivial_term()
  • is_type()
  • is_unit_term()
  • is_unit_type()
  • type_dependencies()
• hydra.query module
  • ComparisonConstraint
    • ComparisonConstraint.EQUAL
    • ComparisonConstraint.GREATER_THAN
    • ComparisonConstraint.GREATER_THAN_OR_EQUAL
    • ComparisonConstraint.LESS_THAN
    • ComparisonConstraint.LESS_THAN_OR_EQUAL
    • ComparisonConstraint.NOT_EQUAL
    • ComparisonConstraint.TYPE_
  • Edge
    • Edge.Builder
      • Edge.Builder.build()
      • Edge.Builder.in_()
      • Edge.Builder.out()
      • Edge.Builder.type()
    • Edge.IN
    • Edge.OUT
    • Edge.TYPE
    • Edge.TYPE_
    • Edge.builder()
    • Edge.in_
    • Edge.out
    • Edge.type
    • Edge.with_in_()
    • Edge.with_out()
    • Edge.with_type()
  • GraphPattern
    • GraphPattern.Builder
      • GraphPattern.Builder.build()
      • GraphPattern.Builder.graph()
      • GraphPattern.Builder.patterns()
    • GraphPattern.GRAPH
    • GraphPattern.PATTERNS
    • GraphPattern.TYPE_
    • GraphPattern.builder()
    • GraphPattern.graph
    • GraphPattern.patterns
    • GraphPattern.with_graph()
    • GraphPattern.with_patterns()
  • NodeTerm
  • NodeVariable
  • NodeWildcard
  • Node_
    • Node_.TERM
    • Node_.TYPE_
    • Node_.VARIABLE
    • Node_.WILDCARD
  • Path
    • Path.INVERSE
    • Path.REGEX
    • Path.STEP
    • Path.TYPE_
  • PathEquation
    • PathEquation.Builder
      • PathEquation.Builder.build()
      • PathEquation.Builder.left()
      • PathEquation.Builder.right()
    • PathEquation.LEFT
    • PathEquation.RIGHT
    • PathEquation.TYPE_
    • PathEquation.builder()
    • PathEquation.left
    • PathEquation.right
    • PathEquation.with_left()
    • PathEquation.with_right()
  • PathInverse
  • PathRegex
  • PathStep
  • Pattern
    • Pattern.CONJUNCTION
    • Pattern.DISJUNCTION
    • Pattern.GRAPH
    • Pattern.NEGATION
    • Pattern.TRIPLE
    • Pattern.TYPE_
  • PatternConjunction
  • PatternDisjunction
  • PatternGraph
  • PatternImplication
    • PatternImplication.ANTECEDENT
    • PatternImplication.Builder
      • PatternImplication.Builder.antecedent()
      • PatternImplication.Builder.build()
      • PatternImplication.Builder.consequent()
    • PatternImplication.CONSEQUENT
    • PatternImplication.TYPE_
    • PatternImplication.antecedent
    • PatternImplication.builder()
    • PatternImplication.consequent
    • PatternImplication.with_antecedent()
    • PatternImplication.with_consequent()
  • PatternNegation
  • PatternTriple
  • Query
    • Query.Builder
      • Query.Builder.build()
      • Query.Builder.patterns()
      • Query.Builder.variables()
    • Query.PATTERNS
    • Query.TYPE_
    • Query.VARIABLES
    • Query.builder()
    • Query.patterns
    • Query.variables
    • Query.with_patterns()
    • Query.with_variables()
  • Range
    • Range.Builder
      • Range.Builder.build()
      • Range.Builder.max()
      • Range.Builder.min()
    • Range.MAX
    • Range.MIN
    • Range.TYPE_
    • Range.builder()
    • Range.max
    • Range.min
    • Range.with_max()
    • Range.with_min()
  • RegexQuantifier
    • RegexQuantifier.AT_LEAST
    • RegexQuantifier.EXACTLY
    • RegexQuantifier.ONE
    • RegexQuantifier.ONE_OR_MORE
    • RegexQuantifier.RANGE
    • RegexQuantifier.TYPE_
    • RegexQuantifier.ZERO_OR_MORE
    • RegexQuantifier.ZERO_OR_ONE
  • RegexQuantifierAtLeast
  • RegexQuantifierExactly
  • RegexQuantifierOne
  • RegexQuantifierOneOrMore
  • RegexQuantifierRange
  • RegexQuantifierZeroOrMore
  • RegexQuantifierZeroOrOne
  • RegexSequence
    • RegexSequence.Builder
      • RegexSequence.Builder.build()
      • RegexSequence.Builder.path()
      • RegexSequence.Builder.quantifier()
    • RegexSequence.PATH
    • RegexSequence.QUANTIFIER
    • RegexSequence.TYPE_
    • RegexSequence.builder()
    • RegexSequence.path
    • RegexSequence.quantifier
    • RegexSequence.with_path()
    • RegexSequence.with_quantifier()
  • Step
    • Step.COMPARE
    • Step.EDGE
    • Step.PROJECT
    • Step.TYPE_
  • StepCompare
  • StepEdge
  • StepProject
  • TriplePattern
    • TriplePattern.Builder
      • TriplePattern.Builder.build()
      • TriplePattern.Builder.object()
      • TriplePattern.Builder.predicate()
      • TriplePattern.Builder.subject()
    • TriplePattern.OBJECT
    • TriplePattern.PREDICATE
    • TriplePattern.SUBJECT
    • TriplePattern.TYPE_
    • TriplePattern.builder()
    • TriplePattern.object
    • TriplePattern.predicate
    • TriplePattern.subject
    • TriplePattern.with_object()
    • TriplePattern.with_predicate()
    • TriplePattern.with_subject()
  • Variable
    • Variable.TYPE_
• hydra.reduction module
  • alpha_convert()
  • beta_reduce_type()
  • contract_term()
  • eta_expand_term()
  • eta_expand_typed_term()
  • eta_expansion_arity()
  • eta_reduce_term()
  • reduce_term()
  • term_is_closed()
  • term_is_value()
• hydra.reflect module
  • float_type_precision()
  • float_value_type()
  • integer_type_is_signed()
  • integer_type_precision()
  • integer_value_type()
  • literal_type()
  • literal_type_variant()
  • literal_types()
  • literal_variant()
  • term_variant()
  • type_variant()
• hydra.refs module
  • decode_ref()
  • encode_list()
  • encode_map()
  • encode_optional()
  • encode_pair()
  • encode_ref()
  • encode_set()
  • show_ref()
• hydra.regex module
  • Atom
    • Atom.ANCHOR_END
    • Atom.ANCHOR_START
    • Atom.ANY
    • Atom.CLASS
    • Atom.GROUP
    • Atom.LITERAL
    • Atom.TYPE_
  • AtomAnchorEnd
  • AtomAnchorStart
  • AtomAny
  • AtomClass
  • AtomGroup
  • AtomLiteral
  • CharacterClass
    • CharacterClass.Builder
      • CharacterClass.Builder.build()
      • CharacterClass.Builder.items()
      • CharacterClass.Builder.negated()
    • CharacterClass.ITEMS
    • CharacterClass.NEGATED
    • CharacterClass.TYPE_
    • CharacterClass.builder()
    • CharacterClass.items
    • CharacterClass.negated
    • CharacterClass.with_items()
    • CharacterClass.with_negated()
  • CharacterRange
    • CharacterRange.Builder
      • CharacterRange.Builder.build()
      • CharacterRange.Builder.from_()
      • CharacterRange.Builder.to()
    • CharacterRange.FROM
    • CharacterRange.TO
    • CharacterRange.TYPE_
    • CharacterRange.builder()
    • CharacterRange.from_
    • CharacterRange.to
    • CharacterRange.with_from_()
    • CharacterRange.with_to()
  • ClassItem
    • ClassItem.CHARACTER
    • ClassItem.RANGE
    • ClassItem.TYPE_
  • ClassItemCharacter
  • ClassItemRange
  • Quantified
    • Quantified.ATOM
    • Quantified.Builder
      • Quantified.Builder.atom()
      • Quantified.Builder.build()
      • Quantified.Builder.quantifier()
    • Quantified.QUANTIFIER
    • Quantified.TYPE_
    • Quantified.atom
    • Quantified.builder()
    • Quantified.quantifier
    • Quantified.with_atom()
    • Quantified.with_quantifier()
  • Quantifier
    • Quantifier.AT_LEAST
    • Quantifier.EXACTLY
    • Quantifier.ONE
    • Quantifier.ONE_OR_MORE
    • Quantifier.RANGE
    • Quantifier.TYPE_
    • Quantifier.ZERO_OR_MORE
    • Quantifier.ZERO_OR_ONE
  • QuantifierAtLeast
  • QuantifierExactly
  • QuantifierOne
  • QuantifierOneOrMore
  • QuantifierRange
    • QuantifierRange.Builder
      • QuantifierRange.Builder.build()
      • QuantifierRange.Builder.max()
      • QuantifierRange.Builder.min()
    • QuantifierRange.MAX
    • QuantifierRange.MIN
    • QuantifierRange.TYPE_
    • QuantifierRange.builder()
    • QuantifierRange.max
    • QuantifierRange.min
    • QuantifierRange.with_max()
    • QuantifierRange.with_min()
  • QuantifierRange_
  • QuantifierZeroOrMore
  • QuantifierZeroOrOne
• hydra.relational module
  • ColumnName
    • ColumnName.TYPE_
  • ColumnSchema
    • ColumnSchema.Builder
      • ColumnSchema.Builder.build()
      • ColumnSchema.Builder.domain()
      • ColumnSchema.Builder.name()
    • ColumnSchema.DOMAIN
    • ColumnSchema.NAME
    • ColumnSchema.TYPE_
    • ColumnSchema.builder()
    • ColumnSchema.domain
    • ColumnSchema.name
    • ColumnSchema.with_domain()
    • ColumnSchema.with_name()
  • ForeignKey
    • ForeignKey.Builder
      • ForeignKey.Builder.build()
      • ForeignKey.Builder.foreign_relation()
      • ForeignKey.Builder.keys()
    • ForeignKey.FOREIGN_RELATION
    • ForeignKey.KEYS
    • ForeignKey.TYPE_
    • ForeignKey.builder()
    • ForeignKey.foreign_relation
    • ForeignKey.keys
    • ForeignKey.with_foreign_relation()
    • ForeignKey.with_keys()
  • PrimaryKey
    • PrimaryKey.TYPE_
  • Relation
    • Relation.TYPE_
  • RelationName
    • RelationName.TYPE_
  • RelationSchema
    • RelationSchema.Builder
      • RelationSchema.Builder.build()
      • RelationSchema.Builder.columns()
      • RelationSchema.Builder.foreign_keys()
      • RelationSchema.Builder.name()
      • RelationSchema.Builder.primary_keys()
    • RelationSchema.COLUMNS
    • RelationSchema.FOREIGN_KEYS
    • RelationSchema.NAME
    • RelationSchema.PRIMARY_KEYS
    • RelationSchema.TYPE_
    • RelationSchema.builder()
    • RelationSchema.columns
    • RelationSchema.foreign_keys
    • RelationSchema.name
    • RelationSchema.primary_keys
    • RelationSchema.with_columns()
    • RelationSchema.with_foreign_keys()
    • RelationSchema.with_name()
    • RelationSchema.with_primary_keys()
  • Relationship
    • Relationship.TYPE_
  • Row
    • Row.TYPE_
• hydra.resolution module
  • dereference_type()
  • f_type_is_polymorphic()
  • field_map()
  • field_type_map()
  • field_types()
  • find_field_type()
  • fully_strip_and_normalize_type()
  • fully_strip_type()
  • instantiate_type()
  • instantiate_type_scheme()
  • map_key_resolves_to_string()
  • nominal_application()
  • require_record_type()
  • require_row_type()
  • require_schema_type()
  • require_type()
  • require_union_field()
  • require_union_type()
  • resolve_base_type()
  • resolve_type()
  • type_to_type_scheme()
• hydra.rewriting module
  • apply_inside_type_lambdas_and_annotations()
  • fold_over_term()
  • fold_over_type()
  • fold_term_with_graph_and_path()
  • map_beneath_type_annotations()
  • rewrite_and_fold_term()
  • rewrite_and_fold_term_with_graph()
  • rewrite_and_fold_term_with_graph_and_path()
  • rewrite_and_fold_term_with_path()
  • rewrite_term()
  • rewrite_term_m()
  • rewrite_term_with_context()
  • rewrite_term_with_context_m()
  • rewrite_term_with_graph()
  • rewrite_type()
  • rewrite_type_m()
  • subterms()
  • subterms_with_steps()
  • subtypes()
  • subtypes_with_steps()
  • wrap_term_to_record()
  • wrap_type_to_record()
• hydra.scoping module
  • extend_graph_for_lambda()
  • extend_graph_for_let()
  • extend_graph_for_type_lambda()
  • extend_graph_with_bindings()
  • f_type_to_type_scheme()
  • term_signature_to_type_scheme()
  • type_scheme_to_f_type()
  • type_scheme_to_term_signature()
• hydra.serialization module
  • angle_braces_list()
  • braces_list_adaptive()
  • bracket_list()
  • bracket_list_adaptive()
  • brackets()
  • choose_layout()
  • comma_sep()
  • comma_sep_adaptive()
  • cst()
  • curly_block()
  • curly_braces_list()
  • custom_indent()
  • custom_indent_block()
  • dot_sep()
  • double_newline_sep()
  • expression_length()
  • ifx()
  • indent()
  • indent_block()
  • indent_subsequent_lines()
  • infix_ws()
  • infix_ws_list()
  • newline_sep()
  • no_sep()
  • num()
  • op()
  • or_op()
  • or_sep()
  • paren_list()
  • paren_list_adaptive()
  • parens()
  • parenthesize()
  • prefix()
  • print_expr()
  • semicolon_sep()
  • sep()
  • space_sep()
  • space_sep_adaptive()
  • structural_sep()
  • structural_space_sep()
  • suffix()
  • sym()
  • symbol_sep()
  • tab_indent()
  • tab_indent_double_space()
  • tab_indent_single_space()
  • unsupported_type()
  • unsupported_variant()
  • with_comma()
  • with_semi()
• hydra.shredding module
  • shred_graph()
  • shred_schema()
  • shred_term()
  • shred_term_links()
  • shred_type()
  • shred_type_links()
  • term_attributes()
  • type_attributes()
• hydra.sorting module
  • adjacency_list_to_map()
  • adjacency_lists_to_graph()
  • create_ordering_isomorphism()
  • find_reachable_nodes()
  • initial_state()
  • pop_stack_until()
  • propagate_tags()
  • strong_connect()
  • strongly_connected_components()
  • topological_sort()
  • topological_sort_components()
  • topological_sort_nodes()
• hydra.strip module
  • deannotate_and_detype_term()
  • deannotate_term()
  • deannotate_type()
  • deannotate_type_parameters()
  • deannotate_type_recursive()
  • deannotate_type_scheme_recursive()
  • detype_term()
  • remove_term_annotations()
  • remove_type_annotations()
  • remove_type_annotations_from_term()
  • remove_types_from_term()
  • strip_type_lambdas()
• hydra.substitution module
  • compose_type_subst()
  • compose_type_subst_list()
  • compose_type_subst_non_empty()
  • id_type_subst()
  • singleton_type_subst()
  • subst_in_class_constraints()
  • subst_in_context()
  • subst_in_type()
  • subst_in_type_non_empty()
  • subst_in_type_scheme()
  • subst_types_in_term()
  • substitute_in_binding()
  • substitute_in_constraint()
  • substitute_in_constraints()
  • substitute_in_term()
• hydra.system module
  • Command
    • Command.ARGUMENTS
    • Command.Builder
      • Command.Builder.arguments()
      • Command.Builder.build()
      • Command.Builder.environment()
      • Command.Builder.program()
      • Command.Builder.working_directory()
    • Command.ENVIRONMENT
    • Command.PROGRAM
    • Command.TYPE_
    • Command.WORKING_DIRECTORY
    • Command.arguments
    • Command.builder()
    • Command.environment
    • Command.program
    • Command.with_arguments()
    • Command.with_environment()
    • Command.with_program()
    • Command.with_working_directory()
    • Command.working_directory
  • EnvironmentVariable
    • EnvironmentVariable.TYPE_
  • ProcessResult
    • ProcessResult.Builder
      • ProcessResult.Builder.build()
      • ProcessResult.Builder.exit_code()
      • ProcessResult.Builder.stderr()
      • ProcessResult.Builder.stdout()
    • ProcessResult.EXIT_CODE
    • ProcessResult.STDERR
    • ProcessResult.STDOUT
    • ProcessResult.TYPE_
    • ProcessResult.builder()
    • ProcessResult.exit_code
    • ProcessResult.stderr
    • ProcessResult.stdout
    • ProcessResult.with_exit_code()
    • ProcessResult.with_stderr()
    • ProcessResult.with_stdout()
  • StatusCode
    • StatusCode.TYPE_
• hydra.tabular module
  • ColumnType
    • ColumnType.Builder
      • ColumnType.Builder.build()
      • ColumnType.Builder.name()
      • ColumnType.Builder.type()
    • ColumnType.NAME
    • ColumnType.TYPE
    • ColumnType.TYPE_
    • ColumnType.builder()
    • ColumnType.name
    • ColumnType.type
    • ColumnType.with_name()
    • ColumnType.with_type()
  • DataRow
    • DataRow.TYPE_
  • HeaderRow
    • HeaderRow.TYPE_
  • Table
    • Table.Builder
      • Table.Builder.build()
      • Table.Builder.data()
      • Table.Builder.header()
    • Table.DATA
    • Table.HEADER
    • Table.TYPE_
    • Table.builder()
    • Table.data
    • Table.header
    • Table.with_data()
    • Table.with_header()
  • TableType
    • TableType.Builder
      • TableType.Builder.build()
      • TableType.Builder.columns()
      • TableType.Builder.name()
    • TableType.COLUMNS
    • TableType.NAME
    • TableType.TYPE_
    • TableType.builder()
    • TableType.columns
    • TableType.name
    • TableType.with_columns()
    • TableType.with_name()
• hydra.templates module
  • graph_to_schema()
  • instantiate_template()
• hydra.testing module
  • EffectfulTestCase
    • EffectfulTestCase.ACTUAL
    • EffectfulTestCase.Builder
      • EffectfulTestCase.Builder.actual()
      • EffectfulTestCase.Builder.build()
      • EffectfulTestCase.Builder.expected()
    • EffectfulTestCase.EXPECTED
    • EffectfulTestCase.TYPE_
    • EffectfulTestCase.actual
    • EffectfulTestCase.builder()
    • EffectfulTestCase.expected
    • EffectfulTestCase.with_actual()
    • EffectfulTestCase.with_expected()
  • Tag
    • Tag.TYPE_
  • TestCase
    • TestCase.EFFECTFUL
    • TestCase.TYPE_
    • TestCase.UNIVERSAL
  • TestCaseEffectful
  • TestCaseUniversal
  • TestCaseWithMetadata
    • TestCaseWithMetadata.Builder
      • TestCaseWithMetadata.Builder.build()
      • TestCaseWithMetadata.Builder.case()
      • TestCaseWithMetadata.Builder.description()
      • TestCaseWithMetadata.Builder.name()
      • TestCaseWithMetadata.Builder.tags()
    • TestCaseWithMetadata.CASE
    • TestCaseWithMetadata.DESCRIPTION
    • TestCaseWithMetadata.NAME
    • TestCaseWithMetadata.TAGS
    • TestCaseWithMetadata.TYPE_
    • TestCaseWithMetadata.builder()
    • TestCaseWithMetadata.case
    • TestCaseWithMetadata.description
    • TestCaseWithMetadata.name
    • TestCaseWithMetadata.tags
    • TestCaseWithMetadata.with_case()
    • TestCaseWithMetadata.with_description()
    • TestCaseWithMetadata.with_name()
    • TestCaseWithMetadata.with_tags()
  • TestGroup
    • TestGroup.Builder
      • TestGroup.Builder.build()
      • TestGroup.Builder.cases()
      • TestGroup.Builder.description()
      • TestGroup.Builder.name()
      • TestGroup.Builder.subgroups()
    • TestGroup.CASES
    • TestGroup.DESCRIPTION
    • TestGroup.NAME
    • TestGroup.SUBGROUPS
    • TestGroup.TYPE_
    • TestGroup.builder()
    • TestGroup.cases
    • TestGroup.description
    • TestGroup.name
    • TestGroup.subgroups
    • TestGroup.with_cases()
    • TestGroup.with_description()
    • TestGroup.with_name()
    • TestGroup.with_subgroups()
  • UniversalTestCase
    • UniversalTestCase.ACTUAL
    • UniversalTestCase.Builder
      • UniversalTestCase.Builder.actual()
      • UniversalTestCase.Builder.build()
      • UniversalTestCase.Builder.expected()
    • UniversalTestCase.EXPECTED
    • UniversalTestCase.TYPE_
    • UniversalTestCase.actual
    • UniversalTestCase.builder()
    • UniversalTestCase.expected
    • UniversalTestCase.with_actual()
    • UniversalTestCase.with_expected()
• hydra.time module
  • Timespec
    • Timespec.Builder
      • Timespec.Builder.build()
      • Timespec.Builder.nanoseconds()
      • Timespec.Builder.seconds()
    • Timespec.NANOSECONDS
    • Timespec.SECONDS
    • Timespec.TYPE_
    • Timespec.builder()
    • Timespec.nanoseconds
    • Timespec.seconds
    • Timespec.with_nanoseconds()
    • Timespec.with_seconds()
• hydra.topology module
  • OrderingIsomorphism
    • OrderingIsomorphism.Builder
      • OrderingIsomorphism.Builder.build()
      • OrderingIsomorphism.Builder.decode()
      • OrderingIsomorphism.Builder.encode()
    • OrderingIsomorphism.DECODE
    • OrderingIsomorphism.ENCODE
    • OrderingIsomorphism.TYPE_
    • OrderingIsomorphism.builder()
    • OrderingIsomorphism.decode
    • OrderingIsomorphism.encode
    • OrderingIsomorphism.with_decode()
    • OrderingIsomorphism.with_encode()
  • TarjanState
    • TarjanState.Builder
      • TarjanState.Builder.build()
      • TarjanState.Builder.counter()
      • TarjanState.Builder.indices()
      • TarjanState.Builder.low_links()
      • TarjanState.Builder.on_stack()
      • TarjanState.Builder.sccs()
      • TarjanState.Builder.stack()
    • TarjanState.COUNTER
    • TarjanState.INDICES
    • TarjanState.LOW_LINKS
    • TarjanState.ON_STACK
    • TarjanState.SCCS
    • TarjanState.STACK
    • TarjanState.TYPE_
    • TarjanState.builder()
    • TarjanState.counter
    • TarjanState.indices
    • TarjanState.low_links
    • TarjanState.on_stack
    • TarjanState.sccs
    • TarjanState.stack
    • TarjanState.with_counter()
    • TarjanState.with_indices()
    • TarjanState.with_low_links()
    • TarjanState.with_on_stack()
    • TarjanState.with_sccs()
    • TarjanState.with_stack()
• hydra.typed module
  • TypedBinding
    • TypedBinding.Builder
      • TypedBinding.Builder.build()
      • TypedBinding.Builder.name()
      • TypedBinding.Builder.term()
    • TypedBinding.NAME
    • TypedBinding.TERM
    • TypedBinding.TYPE_
    • TypedBinding.builder()
    • TypedBinding.name
    • TypedBinding.term
    • TypedBinding.with_name()
    • TypedBinding.with_term()
  • TypedName
    • TypedName.TYPE_
  • TypedTerm
    • TypedTerm.TYPE_
  • TypedTermDefinition
    • TypedTermDefinition.Builder
      • TypedTermDefinition.Builder.build()
      • TypedTermDefinition.Builder.name()
      • TypedTermDefinition.Builder.term()
    • TypedTermDefinition.NAME
    • TypedTermDefinition.TERM
    • TypedTermDefinition.TYPE_
    • TypedTermDefinition.builder()
    • TypedTermDefinition.name
    • TypedTermDefinition.term
    • TypedTermDefinition.with_name()
    • TypedTermDefinition.with_term()
• hydra.typing module
  • FunctionStructure
    • FunctionStructure.BINDINGS
    • FunctionStructure.BODY
    • FunctionStructure.Builder
      • FunctionStructure.Builder.bindings()
      • FunctionStructure.Builder.body()
      • FunctionStructure.Builder.build()
      • FunctionStructure.Builder.codomain()
      • FunctionStructure.Builder.domains()
      • FunctionStructure.Builder.environment()
      • FunctionStructure.Builder.params()
      • FunctionStructure.Builder.type_params()
    • FunctionStructure.CODOMAIN
    • FunctionStructure.DOMAINS
    • FunctionStructure.ENVIRONMENT
    • FunctionStructure.PARAMS
    • FunctionStructure.TYPE_
    • FunctionStructure.TYPE_PARAMS
    • FunctionStructure.bindings
    • FunctionStructure.body
    • FunctionStructure.builder()
    • FunctionStructure.codomain
    • FunctionStructure.domains
    • FunctionStructure.environment
    • FunctionStructure.params
    • FunctionStructure.type_params
    • FunctionStructure.with_bindings()
    • FunctionStructure.with_body()
    • FunctionStructure.with_codomain()
    • FunctionStructure.with_domains()
    • FunctionStructure.with_environment()
    • FunctionStructure.with_params()
    • FunctionStructure.with_type_params()
  • InferenceContext
    • InferenceContext.Builder
      • InferenceContext.Builder.build()
      • InferenceContext.Builder.fresh_type_variable_count()
      • InferenceContext.Builder.trace()
    • InferenceContext.FRESH_TYPE_VARIABLE_COUNT
    • InferenceContext.TRACE
    • InferenceContext.TYPE_
    • InferenceContext.builder()
    • InferenceContext.fresh_type_variable_count
    • InferenceContext.trace
    • InferenceContext.with_fresh_type_variable_count()
    • InferenceContext.with_trace()
  • InferenceResult
    • InferenceResult.Builder
      • InferenceResult.Builder.build()
      • InferenceResult.Builder.class_constraints()
      • InferenceResult.Builder.context()
      • InferenceResult.Builder.subst()
      • InferenceResult.Builder.term()
      • InferenceResult.Builder.type()
    • InferenceResult.CLASS_CONSTRAINTS
    • InferenceResult.CONTEXT
    • InferenceResult.SUBST
    • InferenceResult.TERM
    • InferenceResult.TYPE
    • InferenceResult.TYPE_
    • InferenceResult.builder()
    • InferenceResult.class_constraints
    • InferenceResult.context
    • InferenceResult.subst
    • InferenceResult.term
    • InferenceResult.type
    • InferenceResult.with_class_constraints()
    • InferenceResult.with_context()
    • InferenceResult.with_subst()
    • InferenceResult.with_term()
    • InferenceResult.with_type()
  • Parameter
    • Parameter.Builder
      • Parameter.Builder.build()
      • Parameter.Builder.description()
      • Parameter.Builder.is_lazy()
      • Parameter.Builder.name()
      • Parameter.Builder.type()
    • Parameter.DESCRIPTION
    • Parameter.IS_LAZY
    • Parameter.NAME
    • Parameter.TYPE
    • Parameter.TYPE_
    • Parameter.builder()
    • Parameter.description
    • Parameter.is_lazy
    • Parameter.name
    • Parameter.type
    • Parameter.with_description()
    • Parameter.with_is_lazy()
    • Parameter.with_name()
    • Parameter.with_type()
  • Result
    • Result.Builder
      • Result.Builder.build()
      • Result.Builder.description()
      • Result.Builder.type()
    • Result.DESCRIPTION
    • Result.TYPE
    • Result.TYPE_
    • Result.builder()
    • Result.description
    • Result.type
    • Result.with_description()
    • Result.with_type()
  • TermSignature
    • TermSignature.Builder
      • TermSignature.Builder.build()
      • TermSignature.Builder.parameters()
      • TermSignature.Builder.result()
      • TermSignature.Builder.type_parameters()
    • TermSignature.PARAMETERS
    • TermSignature.RESULT
    • TermSignature.TYPE_
    • TermSignature.TYPE_PARAMETERS
    • TermSignature.builder()
    • TermSignature.parameters
    • TermSignature.result
    • TermSignature.type_parameters
    • TermSignature.with_parameters()
    • TermSignature.with_result()
    • TermSignature.with_type_parameters()
  • TermSubst
    • TermSubst.TYPE_
  • TypeClass
    • TypeClass.Builder
      • TypeClass.Builder.build()
      • TypeClass.Builder.description()
    • TypeClass.DESCRIPTION
    • TypeClass.TYPE_
    • TypeClass.builder()
    • TypeClass.description
    • TypeClass.with_description()
  • TypeConstraint
    • TypeConstraint.Builder
      • TypeConstraint.Builder.build()
      • TypeConstraint.Builder.comment()
      • TypeConstraint.Builder.left()
      • TypeConstraint.Builder.right()
    • TypeConstraint.COMMENT
    • TypeConstraint.LEFT
    • TypeConstraint.RIGHT
    • TypeConstraint.TYPE_
    • TypeConstraint.builder()
    • TypeConstraint.comment
    • TypeConstraint.left
    • TypeConstraint.right
    • TypeConstraint.with_comment()
    • TypeConstraint.with_left()
    • TypeConstraint.with_right()
  • TypeParameter
    • TypeParameter.Builder
      • TypeParameter.Builder.build()
      • TypeParameter.Builder.constraints()
      • TypeParameter.Builder.name()
    • TypeParameter.CONSTRAINTS
    • TypeParameter.NAME
    • TypeParameter.TYPE_
    • TypeParameter.builder()
    • TypeParameter.constraints
    • TypeParameter.name
    • TypeParameter.with_constraints()
    • TypeParameter.with_name()
  • TypeSubst
    • TypeSubst.TYPE_
• hydra.unification module
  • join_types()
  • unify_type_constraints()
  • unify_type_lists()
  • unify_types()
  • variable_occurs_in_type()
• hydra.util module
  • CaseConvention
    • CaseConvention.CAMEL
    • CaseConvention.LOWER_SNAKE
    • CaseConvention.PASCAL
    • CaseConvention.TYPE_
    • CaseConvention.UPPER_SNAKE
  • Comparison
    • Comparison.EQUAL_TO
    • Comparison.GREATER_THAN
    • Comparison.LESS_THAN
    • Comparison.TYPE_
  • ModuleNames
    • ModuleNames.Builder
      • ModuleNames.Builder.build()
      • ModuleNames.Builder.focus()
      • ModuleNames.Builder.mapping()
    • ModuleNames.FOCUS
    • ModuleNames.MAPPING
    • ModuleNames.TYPE_
    • ModuleNames.builder()
    • ModuleNames.focus
    • ModuleNames.mapping
    • ModuleNames.with_focus()
    • ModuleNames.with_mapping()
  • Precision
    • Precision.ARBITRARY
    • Precision.BITS
    • Precision.TYPE_
  • PrecisionArbitrary
  • PrecisionBits
  • QualifiedName
    • QualifiedName.Builder
      • QualifiedName.Builder.build()
      • QualifiedName.Builder.local()
      • QualifiedName.Builder.module_name()
    • QualifiedName.LOCAL
    • QualifiedName.MODULE_NAME
    • QualifiedName.TYPE_
    • QualifiedName.builder()
    • QualifiedName.local
    • QualifiedName.module_name
    • QualifiedName.with_local()
    • QualifiedName.with_module_name()
• hydra.validation module
  • ValidationProfile
    • ValidationProfile.Builder
      • ValidationProfile.Builder.build()
      • ValidationProfile.Builder.error_rules()
      • ValidationProfile.Builder.max_errors()
      • ValidationProfile.Builder.max_warnings()
      • ValidationProfile.Builder.warning_rules()
    • ValidationProfile.ERROR_RULES
    • ValidationProfile.MAX_ERRORS
    • ValidationProfile.MAX_WARNINGS
    • ValidationProfile.TYPE_
    • ValidationProfile.WARNING_RULES
    • ValidationProfile.builder()
    • ValidationProfile.error_rules
    • ValidationProfile.max_errors
    • ValidationProfile.max_warnings
    • ValidationProfile.warning_rules
    • ValidationProfile.with_error_rules()
    • ValidationProfile.with_max_errors()
    • ValidationProfile.with_max_warnings()
    • ValidationProfile.with_warning_rules()
  • ValidationResult
    • ValidationResult.Builder
      • ValidationResult.Builder.build()
      • ValidationResult.Builder.errors()
      • ValidationResult.Builder.warnings()
    • ValidationResult.ERRORS
    • ValidationResult.TYPE_
    • ValidationResult.WARNINGS
    • ValidationResult.builder()
    • ValidationResult.errors
    • ValidationResult.warnings
    • ValidationResult.with_errors()
    • ValidationResult.with_warnings()
• hydra.variables module
  • free_type_variables_in_term()
  • free_variables_in_term()
  • free_variables_in_type()
  • free_variables_in_type_ordered()
  • free_variables_in_type_scheme()
  • free_variables_in_type_scheme_simple()
  • free_variables_in_type_simple()
  • is_free_variable_in_term()
  • normalize_type_variables_in_term()
  • replace_free_term_variable()
  • replace_free_type_variable()
  • substitute_type_variables()
  • substitute_variable()
  • substitute_variables()
  • unshadow_variables()
• hydra.variants module
  • LiteralVariant
    • LiteralVariant.BINARY
    • LiteralVariant.BOOLEAN
    • LiteralVariant.DECIMAL
    • LiteralVariant.FLOAT
    • LiteralVariant.INTEGER
    • LiteralVariant.STRING
    • LiteralVariant.TYPE_
  • TermVariant
    • TermVariant.ANNOTATED
    • TermVariant.APPLICATION
    • TermVariant.CASES
    • TermVariant.EITHER
    • TermVariant.INJECT
    • TermVariant.LAMBDA
    • TermVariant.LET
    • TermVariant.LIST
    • TermVariant.LITERAL
    • TermVariant.MAP
    • TermVariant.OPTIONAL
    • TermVariant.PAIR
    • TermVariant.PROJECT
    • TermVariant.RECORD
    • TermVariant.SET
    • TermVariant.TYPE_
    • TermVariant.TYPE_APPLICATION
    • TermVariant.TYPE_LAMBDA
    • TermVariant.UNIT
    • TermVariant.UNWRAP
    • TermVariant.VARIABLE
    • TermVariant.WRAP
  • TypeVariant
    • TypeVariant.ANNOTATED
    • TypeVariant.APPLICATION
    • TypeVariant.EFFECT
    • TypeVariant.EITHER
    • TypeVariant.FORALL
    • TypeVariant.FUNCTION
    • TypeVariant.LIST
    • TypeVariant.LITERAL
    • TypeVariant.MAP
    • TypeVariant.OPTIONAL
    • TypeVariant.PAIR
    • TypeVariant.RECORD
    • TypeVariant.SET
    • TypeVariant.TYPE_
    • TypeVariant.UNION
    • TypeVariant.UNIT
    • TypeVariant.VARIABLE
    • TypeVariant.VOID
    • TypeVariant.WRAP