hydra-kernel
  • hydra
    • hydra namespace
      • Subpackages
        • hydra.decode namespace
          • Subpackages
            • hydra.decode.error namespace
              • Submodules
                • hydra.decode.error.checking module
                  • checking_error()
                  • incorrect_unification_error()
                  • not_a_forall_type_error()
                  • not_a_function_type_error()
                  • other_checking_error()
                  • type_arity_mismatch_error()
                  • type_mismatch_error()
                  • unbound_type_variables_error()
                  • undefined_term_variable_checking_error()
                  • unequal_types_error()
                  • unsupported_term_variant_error()
                  • untyped_lambda_error()
                  • untyped_let_binding_error()
                  • untyped_term_variable_checking_error()
                • hydra.decode.error.core module
                  • constant_condition_error()
                  • duplicate_binding_error()
                  • duplicate_field_error()
                  • duplicate_record_type_field_names_error()
                  • duplicate_union_type_field_names_error()
                  • empty_case_statement_error()
                  • empty_let_bindings_error()
                  • empty_record_type_error()
                  • empty_term_annotation_error()
                  • empty_type_annotation_error()
                  • empty_type_name_in_term_error()
                  • empty_union_type_error()
                  • extra_record_fields_error()
                  • invalid_forall_parameter_name_error()
                  • invalid_lambda_parameter_name_error()
                  • invalid_let_binding_name_error()
                  • invalid_literal_error()
                  • invalid_term_error()
                  • invalid_type_error()
                  • invalid_type_lambda_parameter_name_error()
                  • invalid_type_scheme_variable_name_error()
                  • literal_type_mismatch_error()
                  • missing_case_branches_error()
                  • missing_record_fields_error()
                  • nested_term_annotation_error()
                  • nested_type_annotation_error()
                  • nominal_type_kind_mismatch_error()
                  • non_comparable_map_key_type_error()
                  • non_comparable_set_element_type_error()
                  • redundant_wrap_unwrap_error()
                  • self_application_error()
                  • single_variant_union_error()
                  • term_variable_shadowing_error()
                  • type_variable_shadowing_in_forall_error()
                  • type_variable_shadowing_in_type_lambda_error()
                  • undeclared_variant_error()
                  • undefined_field_error()
                  • undefined_term_variable_error()
                  • undefined_type_variable_error()
                  • undefined_type_variable_in_binding_type_error()
                  • undefined_type_variable_in_lambda_domain_error()
                  • undefined_type_variable_in_type_application_error()
                  • unexpected_term_variant_error()
                  • unexpected_type_variant_error()
                  • unknown_case_alternative_error()
                  • unknown_primitive_name_error()
                  • unknown_projected_field_error()
                  • unnecessary_identity_application_error()
                  • unresolved_nominal_type_error()
                  • untyped_term_variable_error()
                  • void_in_non_bottom_position_error()
                • hydra.decode.error.file module
                  • file_error()
                • hydra.decode.error.packaging module
                  • conflicting_module_name_error()
                  • conflicting_variant_name_error()
                  • definition_not_in_module_name_error()
                  • definitions_out_of_order_error()
                  • duplicate_definition_name_error()
                  • duplicate_module_name_error()
                  • invalid_definition_name_error()
                  • invalid_module_error()
                  • invalid_module_name_convention_error()
                  • invalid_package_error()
                  • invalid_package_name_error()
                  • missing_documentation_error()
                  • undeclared_dependency_error()
                • hydra.decode.error.system module
                  • system_error()
            • hydra.decode.json namespace
              • Submodules
                • hydra.decode.json.model module
                  • value()
            • hydra.decode.yaml namespace
              • Submodules
                • hydra.decode.yaml.model module
                  • node()
                  • scalar()
          • 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.error.checking module
                  • checking_error_incorrect_unification()
                  • checking_error_not_a_forall_type()
                  • checking_error_not_a_function_type()
                  • checking_error_other()
                  • checking_error_type_arity_mismatch()
                  • checking_error_type_mismatch()
                  • checking_error_unbound_type_variables()
                  • checking_error_undefined_term_variable()
                  • checking_error_unequal_types()
                  • checking_error_unsupported_term_variant()
                  • checking_error_untyped_lambda()
                  • checking_error_untyped_let_binding()
                  • checking_error_untyped_term_variable()
                  • incorrect_unification_error()
                  • incorrect_unification_error_substitution()
                  • incorrect_unification_error_with_substitution()
                  • not_a_forall_type_error()
                  • not_a_forall_type_error_type()
                  • not_a_forall_type_error_type_arguments()
                  • not_a_forall_type_error_with_type()
                  • not_a_forall_type_error_with_type_arguments()
                  • not_a_function_type_error()
                  • not_a_function_type_error_type()
                  • not_a_function_type_error_with_type()
                  • other_checking_error()
                  • other_checking_error_message()
                  • other_checking_error_path()
                  • other_checking_error_with_message()
                  • other_checking_error_with_path()
                  • type_arity_mismatch_error()
                  • type_arity_mismatch_error_actual_arity()
                  • type_arity_mismatch_error_expected_arity()
                  • type_arity_mismatch_error_type()
                  • type_arity_mismatch_error_type_arguments()
                  • type_arity_mismatch_error_with_actual_arity()
                  • type_arity_mismatch_error_with_expected_arity()
                  • type_arity_mismatch_error_with_type()
                  • type_arity_mismatch_error_with_type_arguments()
                  • type_mismatch_error()
                  • type_mismatch_error_actual_type()
                  • type_mismatch_error_expected_type()
                  • type_mismatch_error_with_actual_type()
                  • type_mismatch_error_with_expected_type()
                  • unbound_type_variables_error()
                  • unbound_type_variables_error_type()
                  • unbound_type_variables_error_variables()
                  • unbound_type_variables_error_with_type()
                  • unbound_type_variables_error_with_variables()
                  • undefined_term_variable_checking_error()
                  • undefined_term_variable_checking_error_name()
                  • undefined_term_variable_checking_error_path()
                  • undefined_term_variable_checking_error_with_name()
                  • undefined_term_variable_checking_error_with_path()
                  • unequal_types_error()
                  • unequal_types_error_description()
                  • unequal_types_error_types()
                  • unequal_types_error_with_description()
                  • unequal_types_error_with_types()
                  • unsupported_term_variant_error()
                  • unsupported_term_variant_error_term_variant()
                  • unsupported_term_variant_error_with_term_variant()
                  • untyped_let_binding_error()
                  • untyped_let_binding_error_binding()
                  • untyped_let_binding_error_with_binding()
                  • untyped_term_variable_checking_error()
                  • untyped_term_variable_checking_error_name()
                  • untyped_term_variable_checking_error_path()
                  • untyped_term_variable_checking_error_with_name()
                  • untyped_term_variable_checking_error_with_path()
                • hydra.dsl.error.core module
                  • constant_condition_error()
                  • constant_condition_error_location()
                  • constant_condition_error_value()
                  • constant_condition_error_with_location()
                  • constant_condition_error_with_value()
                  • duplicate_binding_error()
                  • duplicate_binding_error_location()
                  • duplicate_binding_error_name()
                  • duplicate_binding_error_with_location()
                  • duplicate_binding_error_with_name()
                  • duplicate_field_error()
                  • duplicate_field_error_location()
                  • duplicate_field_error_name()
                  • duplicate_field_error_with_location()
                  • duplicate_field_error_with_name()
                  • duplicate_record_type_field_names_error()
                  • duplicate_record_type_field_names_error_location()
                  • duplicate_record_type_field_names_error_name()
                  • duplicate_record_type_field_names_error_with_location()
                  • duplicate_record_type_field_names_error_with_name()
                  • duplicate_union_type_field_names_error()
                  • duplicate_union_type_field_names_error_location()
                  • duplicate_union_type_field_names_error_name()
                  • duplicate_union_type_field_names_error_with_location()
                  • duplicate_union_type_field_names_error_with_name()
                  • empty_case_statement_error()
                  • empty_case_statement_error_location()
                  • empty_case_statement_error_type_name()
                  • empty_case_statement_error_with_location()
                  • empty_case_statement_error_with_type_name()
                  • empty_let_bindings_error()
                  • empty_let_bindings_error_location()
                  • empty_let_bindings_error_with_location()
                  • empty_record_type_error()
                  • empty_record_type_error_location()
                  • empty_record_type_error_with_location()
                  • empty_term_annotation_error()
                  • empty_term_annotation_error_location()
                  • empty_term_annotation_error_with_location()
                  • empty_type_annotation_error()
                  • empty_type_annotation_error_location()
                  • empty_type_annotation_error_with_location()
                  • empty_type_name_in_term_error()
                  • empty_type_name_in_term_error_location()
                  • empty_type_name_in_term_error_with_location()
                  • empty_union_type_error()
                  • empty_union_type_error_location()
                  • empty_union_type_error_with_location()
                  • extra_record_fields_error()
                  • extra_record_fields_error_field_names()
                  • extra_record_fields_error_location()
                  • extra_record_fields_error_type_name()
                  • extra_record_fields_error_with_field_names()
                  • extra_record_fields_error_with_location()
                  • extra_record_fields_error_with_type_name()
                  • invalid_forall_parameter_name_error()
                  • invalid_forall_parameter_name_error_location()
                  • invalid_forall_parameter_name_error_name()
                  • invalid_forall_parameter_name_error_with_location()
                  • invalid_forall_parameter_name_error_with_name()
                  • invalid_lambda_parameter_name_error()
                  • invalid_lambda_parameter_name_error_location()
                  • invalid_lambda_parameter_name_error_name()
                  • invalid_lambda_parameter_name_error_with_location()
                  • invalid_lambda_parameter_name_error_with_name()
                  • invalid_let_binding_name_error()
                  • invalid_let_binding_name_error_location()
                  • invalid_let_binding_name_error_name()
                  • invalid_let_binding_name_error_with_location()
                  • invalid_let_binding_name_error_with_name()
                  • invalid_literal_error_type_mismatch()
                  • invalid_term_error_constant_condition()
                  • invalid_term_error_duplicate_binding()
                  • invalid_term_error_duplicate_field()
                  • invalid_term_error_empty_case_statement()
                  • invalid_term_error_empty_let_bindings()
                  • invalid_term_error_empty_term_annotation()
                  • invalid_term_error_empty_type_name_in_term()
                  • invalid_term_error_extra_record_fields()
                  • invalid_term_error_invalid_lambda_parameter_name()
                  • invalid_term_error_invalid_let_binding_name()
                  • invalid_term_error_invalid_type_lambda_parameter_name()
                  • invalid_term_error_missing_case_branches()
                  • invalid_term_error_missing_record_fields()
                  • invalid_term_error_nested_term_annotation()
                  • invalid_term_error_nominal_type_kind_mismatch()
                  • invalid_term_error_redundant_wrap_unwrap()
                  • invalid_term_error_self_application()
                  • invalid_term_error_term_variable_shadowing()
                  • invalid_term_error_type_variable_shadowing_in_type_lambda()
                  • invalid_term_error_undeclared_variant()
                  • invalid_term_error_undefined_term_variable()
                  • invalid_term_error_undefined_type_variable_in_binding_type()
                  • invalid_term_error_undefined_type_variable_in_lambda_domain()
                  • invalid_term_error_undefined_type_variable_in_type_application()
                  • invalid_term_error_unknown_case_alternative()
                  • invalid_term_error_unknown_primitive_name()
                  • invalid_term_error_unknown_projected_field()
                  • invalid_term_error_unnecessary_identity_application()
                  • invalid_term_error_unresolved_nominal_type()
                  • invalid_term_error_untyped_term_variable()
                  • invalid_type_error_duplicate_record_type_field_names()
                  • invalid_type_error_duplicate_union_type_field_names()
                  • invalid_type_error_empty_record_type()
                  • invalid_type_error_empty_type_annotation()
                  • invalid_type_error_empty_union_type()
                  • invalid_type_error_invalid_forall_parameter_name()
                  • invalid_type_error_invalid_type_scheme_variable_name()
                  • invalid_type_error_nested_type_annotation()
                  • invalid_type_error_non_comparable_map_key_type()
                  • invalid_type_error_non_comparable_set_element_type()
                  • invalid_type_error_single_variant_union()
                  • invalid_type_error_type_variable_shadowing_in_forall()
                  • invalid_type_error_undefined_type_variable()
                  • invalid_type_error_void_in_non_bottom_position()
                  • invalid_type_lambda_parameter_name_error()
                  • invalid_type_lambda_parameter_name_error_location()
                  • invalid_type_lambda_parameter_name_error_name()
                  • invalid_type_lambda_parameter_name_error_with_location()
                  • invalid_type_lambda_parameter_name_error_with_name()
                  • invalid_type_scheme_variable_name_error()
                  • invalid_type_scheme_variable_name_error_location()
                  • invalid_type_scheme_variable_name_error_name()
                  • invalid_type_scheme_variable_name_error_with_location()
                  • invalid_type_scheme_variable_name_error_with_name()
                  • literal_type_mismatch_error()
                  • literal_type_mismatch_error_actual_type()
                  • literal_type_mismatch_error_expected_type()
                  • literal_type_mismatch_error_with_actual_type()
                  • literal_type_mismatch_error_with_expected_type()
                  • missing_case_branches_error()
                  • missing_case_branches_error_location()
                  • missing_case_branches_error_type_name()
                  • missing_case_branches_error_variant_names()
                  • missing_case_branches_error_with_location()
                  • missing_case_branches_error_with_type_name()
                  • missing_case_branches_error_with_variant_names()
                  • missing_record_fields_error()
                  • missing_record_fields_error_field_names()
                  • missing_record_fields_error_location()
                  • missing_record_fields_error_type_name()
                  • missing_record_fields_error_with_field_names()
                  • missing_record_fields_error_with_location()
                  • missing_record_fields_error_with_type_name()
                  • nested_term_annotation_error()
                  • nested_term_annotation_error_location()
                  • nested_term_annotation_error_with_location()
                  • nested_type_annotation_error()
                  • nested_type_annotation_error_location()
                  • nested_type_annotation_error_with_location()
                  • nominal_type_kind_mismatch_error()
                  • nominal_type_kind_mismatch_error_actual_variant()
                  • nominal_type_kind_mismatch_error_expected_variant()
                  • nominal_type_kind_mismatch_error_location()
                  • nominal_type_kind_mismatch_error_type_name()
                  • nominal_type_kind_mismatch_error_with_actual_variant()
                  • nominal_type_kind_mismatch_error_with_expected_variant()
                  • nominal_type_kind_mismatch_error_with_location()
                  • nominal_type_kind_mismatch_error_with_type_name()
                  • non_comparable_map_key_type_error()
                  • non_comparable_map_key_type_error_key_type()
                  • non_comparable_map_key_type_error_location()
                  • non_comparable_map_key_type_error_with_key_type()
                  • non_comparable_map_key_type_error_with_location()
                  • non_comparable_set_element_type_error()
                  • non_comparable_set_element_type_error_element_type()
                  • non_comparable_set_element_type_error_location()
                  • non_comparable_set_element_type_error_with_element_type()
                  • non_comparable_set_element_type_error_with_location()
                  • redundant_wrap_unwrap_error()
                  • redundant_wrap_unwrap_error_location()
                  • redundant_wrap_unwrap_error_type_name()
                  • redundant_wrap_unwrap_error_with_location()
                  • redundant_wrap_unwrap_error_with_type_name()
                  • self_application_error()
                  • self_application_error_location()
                  • self_application_error_name()
                  • self_application_error_with_location()
                  • self_application_error_with_name()
                  • single_variant_union_error()
                  • single_variant_union_error_field_name()
                  • single_variant_union_error_location()
                  • single_variant_union_error_with_field_name()
                  • single_variant_union_error_with_location()
                  • term_variable_shadowing_error()
                  • term_variable_shadowing_error_location()
                  • term_variable_shadowing_error_name()
                  • term_variable_shadowing_error_with_location()
                  • term_variable_shadowing_error_with_name()
                  • type_variable_shadowing_in_forall_error()
                  • type_variable_shadowing_in_forall_error_location()
                  • type_variable_shadowing_in_forall_error_name()
                  • type_variable_shadowing_in_forall_error_with_location()
                  • type_variable_shadowing_in_forall_error_with_name()
                  • type_variable_shadowing_in_type_lambda_error()
                  • type_variable_shadowing_in_type_lambda_error_location()
                  • type_variable_shadowing_in_type_lambda_error_name()
                  • type_variable_shadowing_in_type_lambda_error_with_location()
                  • type_variable_shadowing_in_type_lambda_error_with_name()
                  • undeclared_variant_error()
                  • undeclared_variant_error_location()
                  • undeclared_variant_error_type_name()
                  • undeclared_variant_error_variant_name()
                  • undeclared_variant_error_with_location()
                  • undeclared_variant_error_with_type_name()
                  • undeclared_variant_error_with_variant_name()
                  • undefined_field_error()
                  • undefined_field_error_field_name()
                  • undefined_field_error_type_name()
                  • undefined_field_error_with_field_name()
                  • undefined_field_error_with_type_name()
                  • undefined_term_variable_error()
                  • undefined_term_variable_error_location()
                  • undefined_term_variable_error_name()
                  • undefined_term_variable_error_with_location()
                  • undefined_term_variable_error_with_name()
                  • undefined_type_variable_error()
                  • undefined_type_variable_error_location()
                  • undefined_type_variable_error_name()
                  • undefined_type_variable_error_with_location()
                  • undefined_type_variable_error_with_name()
                  • undefined_type_variable_in_binding_type_error()
                  • undefined_type_variable_in_binding_type_error_location()
                  • undefined_type_variable_in_binding_type_error_name()
                  • undefined_type_variable_in_binding_type_error_with_location()
                  • undefined_type_variable_in_binding_type_error_with_name()
                  • undefined_type_variable_in_lambda_domain_error()
                  • undefined_type_variable_in_lambda_domain_error_location()
                  • undefined_type_variable_in_lambda_domain_error_name()
                  • undefined_type_variable_in_lambda_domain_error_with_location()
                  • undefined_type_variable_in_lambda_domain_error_with_name()
                  • undefined_type_variable_in_type_application_error()
                  • undefined_type_variable_in_type_application_error_location()
                  • undefined_type_variable_in_type_application_error_name()
                  • undefined_type_variable_in_type_application_error_with_location()
                  • undefined_type_variable_in_type_application_error_with_name()
                  • unexpected_term_variant_error()
                  • unexpected_term_variant_error_actual_term()
                  • unexpected_term_variant_error_expected_variant()
                  • unexpected_term_variant_error_with_actual_term()
                  • unexpected_term_variant_error_with_expected_variant()
                  • unexpected_type_variant_error()
                  • unexpected_type_variant_error_actual_type()
                  • unexpected_type_variant_error_expected_variant()
                  • unexpected_type_variant_error_with_actual_type()
                  • unexpected_type_variant_error_with_expected_variant()
                  • unknown_case_alternative_error()
                  • unknown_case_alternative_error_location()
                  • unknown_case_alternative_error_name()
                  • unknown_case_alternative_error_type_name()
                  • unknown_case_alternative_error_with_location()
                  • unknown_case_alternative_error_with_name()
                  • unknown_case_alternative_error_with_type_name()
                  • unknown_primitive_name_error()
                  • unknown_primitive_name_error_location()
                  • unknown_primitive_name_error_name()
                  • unknown_primitive_name_error_with_location()
                  • unknown_primitive_name_error_with_name()
                  • unknown_projected_field_error()
                  • unknown_projected_field_error_field_name()
                  • unknown_projected_field_error_location()
                  • unknown_projected_field_error_type_name()
                  • unknown_projected_field_error_with_field_name()
                  • unknown_projected_field_error_with_location()
                  • unknown_projected_field_error_with_type_name()
                  • unnecessary_identity_application_error()
                  • unnecessary_identity_application_error_location()
                  • unnecessary_identity_application_error_with_location()
                  • unresolved_nominal_type_error()
                  • unresolved_nominal_type_error_location()
                  • unresolved_nominal_type_error_type_name()
                  • unresolved_nominal_type_error_with_location()
                  • unresolved_nominal_type_error_with_type_name()
                  • untyped_term_variable_error()
                  • untyped_term_variable_error_location()
                  • untyped_term_variable_error_name()
                  • untyped_term_variable_error_with_location()
                  • untyped_term_variable_error_with_name()
                  • void_in_non_bottom_position_error()
                  • void_in_non_bottom_position_error_location()
                  • void_in_non_bottom_position_error_with_location()
                • hydra.dsl.error.file module
                  • file_error_already_exists()
                  • file_error_invalid_path()
                  • file_error_not_found()
                  • file_error_other()
                  • file_error_permission_denied()
                • hydra.dsl.error.packaging module
                  • conflicting_module_name_error()
                  • conflicting_module_name_error_first()
                  • conflicting_module_name_error_second()
                  • conflicting_module_name_error_with_first()
                  • conflicting_module_name_error_with_second()
                  • conflicting_variant_name_error()
                  • conflicting_variant_name_error_conflicting_name()
                  • conflicting_variant_name_error_module_name()
                  • conflicting_variant_name_error_type_name()
                  • conflicting_variant_name_error_variant_name()
                  • conflicting_variant_name_error_with_conflicting_name()
                  • conflicting_variant_name_error_with_module_name()
                  • conflicting_variant_name_error_with_type_name()
                  • conflicting_variant_name_error_with_variant_name()
                  • definition_not_in_module_name_error()
                  • definition_not_in_module_name_error_module_name()
                  • definition_not_in_module_name_error_name()
                  • definition_not_in_module_name_error_with_module_name()
                  • definition_not_in_module_name_error_with_name()
                  • definitions_out_of_order_error()
                  • definitions_out_of_order_error_following_name()
                  • definitions_out_of_order_error_module_name()
                  • definitions_out_of_order_error_preceding_name()
                  • definitions_out_of_order_error_with_following_name()
                  • definitions_out_of_order_error_with_module_name()
                  • definitions_out_of_order_error_with_preceding_name()
                  • duplicate_definition_name_error()
                  • duplicate_definition_name_error_module_name()
                  • duplicate_definition_name_error_name()
                  • duplicate_definition_name_error_with_module_name()
                  • duplicate_definition_name_error_with_name()
                  • duplicate_module_name_error()
                  • duplicate_module_name_error_module_name()
                  • duplicate_module_name_error_with_module_name()
                  • invalid_definition_name_error()
                  • invalid_definition_name_error_expected_convention()
                  • invalid_definition_name_error_module_name()
                  • invalid_definition_name_error_name()
                  • invalid_definition_name_error_with_expected_convention()
                  • invalid_definition_name_error_with_module_name()
                  • invalid_definition_name_error_with_name()
                  • invalid_module_error_conflicting_variant_name()
                  • invalid_module_error_definition_not_in_module_name()
                  • invalid_module_error_definitions_out_of_order()
                  • invalid_module_error_duplicate_definition_name()
                  • invalid_module_error_invalid_definition_name()
                  • invalid_module_error_invalid_module_name_convention()
                  • invalid_module_error_missing_documentation()
                  • invalid_module_name_convention_error()
                  • invalid_module_name_convention_error_module_name()
                  • invalid_module_name_convention_error_with_module_name()
                  • invalid_package_error_conflicting_module_name()
                  • invalid_package_error_duplicate_module_name()
                  • invalid_package_error_invalid_module()
                  • invalid_package_error_invalid_package_name()
                  • invalid_package_error_undeclared_dependency()
                  • invalid_package_name_error()
                  • invalid_package_name_error_package_name()
                  • invalid_package_name_error_with_package_name()
                  • missing_documentation_error()
                  • missing_documentation_error_module_name()
                  • missing_documentation_error_name()
                  • missing_documentation_error_with_module_name()
                  • missing_documentation_error_with_name()
                  • undeclared_dependency_error()
                  • undeclared_dependency_error_module_name()
                  • undeclared_dependency_error_owning_module_name()
                  • undeclared_dependency_error_referenced_name()
                  • undeclared_dependency_error_with_module_name()
                  • undeclared_dependency_error_with_owning_module_name()
                  • undeclared_dependency_error_with_referenced_name()
                • hydra.dsl.error.system module
                  • system_error_command_not_found()
                  • system_error_invalid_working_directory()
                  • system_error_other()
                  • system_error_permission_denied()
            • hydra.dsl.extract namespace
              • Submodules
                • hydra.dsl.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.dsl.json namespace
              • Subpackages
                • hydra.dsl.json.yaml namespace
                  • Submodules
                    • hydra.dsl.json.yaml.decode module
                      • from_yaml()
                      • yaml_to_json()
                    • hydra.dsl.json.yaml.encode module
                      • json_to_yaml()
                      • to_yaml()
              • Submodules
                • hydra.dsl.json.bootstrap module
                • hydra.dsl.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.dsl.json.decoding module
                  • decode_array()
                  • decode_boolean()
                  • decode_field()
                  • decode_object()
                  • decode_optional_field()
                  • decode_string()
                • hydra.dsl.json.encode module
                  • encode_float()
                  • encode_integer()
                  • encode_literal()
                  • requires_json_string_sentinel()
                  • to_json()
                  • to_json_untyped()
                • hydra.dsl.json.model module
                  • value_array()
                  • value_boolean()
                  • value_number()
                  • value_object()
                  • value_string()
                • hydra.dsl.json.parser module
                  • parse_json()
                  • token()
                • hydra.dsl.json.writer module
                  • hex_byte()
                  • json_string()
                  • key_value_to_expr()
                  • print_json()
                  • value_to_expr()
            • hydra.dsl.lib namespace
              • Submodules
                • hydra.dsl.lib.chars module
                  • is_alpha()
                  • is_alpha_num()
                  • is_digit()
                  • is_lower()
                  • is_space()
                  • is_upper()
                  • to_lower()
                  • to_upper()
                • hydra.dsl.lib.defaults module
                • hydra.dsl.lib.effects module
                  • apply()
                  • bind()
                  • compose()
                  • fold_list()
                  • map()
                  • map_list()
                  • map_optional()
                  • map_set()
                  • pure()
                • hydra.dsl.lib.eithers module
                  • apply()
                  • bimap()
                  • bind()
                  • compose()
                  • either()
                  • fold_list()
                  • is_left()
                  • is_right()
                  • left()
                  • lefts()
                  • map()
                  • map_list()
                  • map_optional()
                  • map_set()
                  • partition()
                  • right()
                  • rights()
                • hydra.dsl.lib.equality module
                  • equal()
                  • not_equal()
                • hydra.dsl.lib.files module
                  • append_file()
                  • copy()
                  • create_directory()
                  • create_symlink()
                  • exists()
                  • list_directory()
                  • read_file()
                  • read_symlink()
                  • remove_directory()
                  • remove_file()
                  • rename()
                  • status()
                  • write_file()
                • hydra.dsl.lib.functions module
                  • compose()
                  • const()
                  • flip()
                  • identity()
                • hydra.dsl.lib.lists module
                  • apply()
                  • at()
                  • bind()
                  • compose()
                  • concat()
                  • concat2()
                  • cons()
                  • distinct()
                  • drop()
                  • drop_while()
                  • filter()
                  • find()
                  • fold_list()
                  • foldl()
                  • foldr()
                  • group()
                  • head()
                  • init()
                  • intersperse()
                  • is_empty()
                  • join()
                  • last()
                  • length()
                  • map()
                  • map_list()
                  • map_optional()
                  • map_set()
                  • member()
                  • partition()
                  • replicate()
                  • reverse()
                  • singleton()
                  • sort()
                  • sort_by()
                  • span()
                  • tail()
                  • take()
                  • take_while()
                  • transpose()
                  • uncons()
                  • zip()
                  • zip_with()
                • hydra.dsl.lib.literals module
                  • base64_to_binary()
                  • bigint_to_decimal()
                  • bigint_to_int16()
                  • bigint_to_int32()
                  • bigint_to_int64()
                  • bigint_to_int8()
                  • bigint_to_uint16()
                  • bigint_to_uint32()
                  • bigint_to_uint64()
                  • bigint_to_uint8()
                  • binary_to_base64()
                  • binary_to_bytes()
                  • decimal_to_bigint()
                  • decimal_to_float32()
                  • decimal_to_float64()
                  • float32_to_decimal()
                  • float32_to_float64()
                  • float64_to_decimal()
                  • float64_to_float32()
                  • int16_to_bigint()
                  • int32_to_bigint()
                  • int64_to_bigint()
                  • int8_to_bigint()
                  • parse_bigint()
                  • parse_boolean()
                  • parse_decimal()
                  • parse_float32()
                  • parse_float64()
                  • parse_int16()
                  • parse_int32()
                  • parse_int64()
                  • parse_int8()
                  • parse_string()
                  • parse_uint16()
                  • parse_uint32()
                  • parse_uint64()
                  • parse_uint8()
                  • print_bigint()
                  • print_boolean()
                  • print_decimal()
                  • print_float32()
                  • print_float64()
                  • print_int16()
                  • print_int32()
                  • print_int64()
                  • print_int8()
                  • print_string()
                  • print_uint16()
                  • print_uint32()
                  • print_uint64()
                  • print_uint8()
                  • uint16_to_bigint()
                  • uint32_to_bigint()
                  • uint64_to_bigint()
                  • uint8_to_bigint()
                • hydra.dsl.lib.logic module
                  • and_()
                  • if_else()
                  • not_()
                  • or_()
                • hydra.dsl.lib.maps module
                  • alter()
                  • bimap()
                  • delete()
                  • difference()
                  • elems()
                  • empty()
                  • filter()
                  • filter_with_key()
                  • find_with_default()
                  • from_list()
                  • insert()
                  • intersection()
                  • is_empty()
                  • keys()
                  • lookup()
                  • map()
                  • map_keys()
                  • member()
                  • singleton()
                  • size()
                  • to_list()
                  • union()
                  • unions()
                • hydra.dsl.lib.math module
                  • abs()
                  • acos()
                  • acosh()
                  • add()
                  • add_float64()
                  • asin()
                  • asinh()
                  • atan()
                  • atan2()
                  • atanh()
                  • ceiling()
                  • cos()
                  • cosh()
                  • div()
                  • divide()
                  • even()
                  • exp()
                  • floor()
                  • log()
                  • log_base()
                  • mod()
                  • mul()
                  • mul_float64()
                  • negate()
                  • negate_float64()
                  • odd()
                  • pow()
                  • range_()
                  • rem()
                  • round()
                  • round_float32()
                  • round_float64()
                  • signum()
                  • sin()
                  • sinh()
                  • sqrt()
                  • sub()
                  • sub_float64()
                  • tan()
                  • tanh()
                  • truncate()
                • hydra.dsl.lib.optionals module
                  • apply()
                  • bind()
                  • compose()
                  • fold_list()
                  • given()
                  • givens()
                  • is_given()
                  • is_none()
                  • map()
                  • map_list()
                  • map_optional()
                  • map_set()
                  • match()
                  • to_list()
                  • with_default()
                • hydra.dsl.lib.ordering module
                  • compare()
                  • gt()
                  • gte()
                  • lt()
                  • lte()
                  • max()
                  • min()
                • hydra.dsl.lib.pairs module
                  • bimap()
                  • first()
                  • pair()
                  • second()
                • hydra.dsl.lib.regex module
                  • find()
                  • find_all()
                  • matches()
                  • replace()
                  • replace_all()
                  • split()
                • hydra.dsl.lib.sets module
                  • delete()
                  • difference()
                  • empty()
                  • filter()
                  • from_list()
                  • insert()
                  • intersection()
                  • is_empty()
                  • map()
                  • member()
                  • singleton()
                  • size()
                  • to_list()
                  • union()
                  • unions()
                • hydra.dsl.lib.strings module
                  • char_at()
                  • concat()
                  • concat2()
                  • from_list()
                  • is_empty()
                  • join()
                  • length()
                  • split_on()
                  • to_list()
                  • to_lower()
                  • to_upper()
                • hydra.dsl.lib.system module
                  • execute()
                  • exit()
                  • get_environment_variable()
                  • write_stderr()
                  • write_stdout()
                • hydra.dsl.lib.text module
                  • decode_utf8()
                  • encode_utf8()
            • hydra.dsl.print namespace
              • Submodules
                • hydra.dsl.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.dsl.test namespace
              • Submodules
                • hydra.dsl.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.dsl.test.utils module
                  • infer_term()
                  • infer_test_case()
                  • infer_test_group_terms()
            • hydra.dsl.yaml namespace
              • Submodules
                • hydra.dsl.yaml.model module
                  • node_mapping()
                  • node_scalar()
                  • node_sequence()
                  • scalar_bool()
                  • scalar_decimal()
                  • scalar_float()
                  • scalar_int()
                  • scalar_str()
          • 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.error.checking module
                  • checking_error()
                  • incorrect_unification_error()
                  • not_a_forall_type_error()
                  • not_a_function_type_error()
                  • other_checking_error()
                  • type_arity_mismatch_error()
                  • type_mismatch_error()
                  • unbound_type_variables_error()
                  • undefined_term_variable_checking_error()
                  • unequal_types_error()
                  • unsupported_term_variant_error()
                  • untyped_lambda_error()
                  • untyped_let_binding_error()
                  • untyped_term_variable_checking_error()
                • hydra.encode.error.core module
                  • constant_condition_error()
                  • duplicate_binding_error()
                  • duplicate_field_error()
                  • duplicate_record_type_field_names_error()
                  • duplicate_union_type_field_names_error()
                  • empty_case_statement_error()
                  • empty_let_bindings_error()
                  • empty_record_type_error()
                  • empty_term_annotation_error()
                  • empty_type_annotation_error()
                  • empty_type_name_in_term_error()
                  • empty_union_type_error()
                  • extra_record_fields_error()
                  • invalid_forall_parameter_name_error()
                  • invalid_lambda_parameter_name_error()
                  • invalid_let_binding_name_error()
                  • invalid_literal_error()
                  • invalid_term_error()
                  • invalid_type_error()
                  • invalid_type_lambda_parameter_name_error()
                  • invalid_type_scheme_variable_name_error()
                  • literal_type_mismatch_error()
                  • missing_case_branches_error()
                  • missing_record_fields_error()
                  • nested_term_annotation_error()
                  • nested_type_annotation_error()
                  • nominal_type_kind_mismatch_error()
                  • non_comparable_map_key_type_error()
                  • non_comparable_set_element_type_error()
                  • redundant_wrap_unwrap_error()
                  • self_application_error()
                  • single_variant_union_error()
                  • term_variable_shadowing_error()
                  • type_variable_shadowing_in_forall_error()
                  • type_variable_shadowing_in_type_lambda_error()
                  • undeclared_variant_error()
                  • undefined_field_error()
                  • undefined_term_variable_error()
                  • undefined_type_variable_error()
                  • undefined_type_variable_in_binding_type_error()
                  • undefined_type_variable_in_lambda_domain_error()
                  • undefined_type_variable_in_type_application_error()
                  • unexpected_term_variant_error()
                  • unexpected_type_variant_error()
                  • unknown_case_alternative_error()
                  • unknown_primitive_name_error()
                  • unknown_projected_field_error()
                  • unnecessary_identity_application_error()
                  • unresolved_nominal_type_error()
                  • untyped_term_variable_error()
                  • void_in_non_bottom_position_error()
                • hydra.encode.error.file module
                  • file_error()
                • hydra.encode.error.packaging module
                  • conflicting_module_name_error()
                  • conflicting_variant_name_error()
                  • definition_not_in_module_name_error()
                  • definitions_out_of_order_error()
                  • duplicate_definition_name_error()
                  • duplicate_module_name_error()
                  • invalid_definition_name_error()
                  • invalid_module_error()
                  • invalid_module_name_convention_error()
                  • invalid_package_error()
                  • invalid_package_name_error()
                  • missing_documentation_error()
                  • undeclared_dependency_error()
                • hydra.encode.error.system module
                  • system_error()
            • hydra.encode.json namespace
              • Submodules
                • hydra.encode.json.model module
                  • value()
            • hydra.encode.yaml namespace
              • Submodules
                • hydra.encode.yaml.model module
                  • node()
                  • scalar()
          • 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
                • CheckingError.INCORRECT_UNIFICATION
                • CheckingError.NOT_A_FORALL_TYPE
                • CheckingError.NOT_A_FUNCTION_TYPE
                • CheckingError.OTHER
                • CheckingError.TYPE_
                • CheckingError.TYPE_ARITY_MISMATCH
                • CheckingError.TYPE_MISMATCH
                • CheckingError.UNBOUND_TYPE_VARIABLES
                • CheckingError.UNDEFINED_TERM_VARIABLE
                • CheckingError.UNEQUAL_TYPES
                • CheckingError.UNSUPPORTED_TERM_VARIANT
                • CheckingError.UNTYPED_LAMBDA
                • CheckingError.UNTYPED_LET_BINDING
                • CheckingError.UNTYPED_TERM_VARIABLE
              • CheckingErrorIncorrectUnification
              • CheckingErrorNotAForallType
              • CheckingErrorNotAFunctionType
              • CheckingErrorOther
              • CheckingErrorTypeArityMismatch
              • CheckingErrorTypeMismatch
              • CheckingErrorUnboundTypeVariables
              • CheckingErrorUndefinedTermVariable
              • CheckingErrorUnequalTypes
              • CheckingErrorUnsupportedTermVariant
              • CheckingErrorUntypedLambda
              • CheckingErrorUntypedLetBinding
              • CheckingErrorUntypedTermVariable
              • IncorrectUnificationError
                • IncorrectUnificationError.Builder
                  • IncorrectUnificationError.Builder.build()
                  • IncorrectUnificationError.Builder.substitution()
                • IncorrectUnificationError.SUBSTITUTION
                • IncorrectUnificationError.TYPE_
                • IncorrectUnificationError.builder()
                • IncorrectUnificationError.substitution
                • IncorrectUnificationError.with_substitution()
              • NotAForallTypeError
                • NotAForallTypeError.Builder
                  • NotAForallTypeError.Builder.build()
                  • NotAForallTypeError.Builder.type()
                  • NotAForallTypeError.Builder.type_arguments()
                • NotAForallTypeError.TYPE
                • NotAForallTypeError.TYPE_
                • NotAForallTypeError.TYPE_ARGUMENTS
                • NotAForallTypeError.builder()
                • NotAForallTypeError.type
                • NotAForallTypeError.type_arguments
                • NotAForallTypeError.with_type()
                • NotAForallTypeError.with_type_arguments()
              • NotAFunctionTypeError
                • NotAFunctionTypeError.Builder
                  • NotAFunctionTypeError.Builder.build()
                  • NotAFunctionTypeError.Builder.type()
                • NotAFunctionTypeError.TYPE
                • NotAFunctionTypeError.TYPE_
                • NotAFunctionTypeError.builder()
                • NotAFunctionTypeError.type
                • NotAFunctionTypeError.with_type()
              • OtherCheckingError
                • OtherCheckingError.Builder
                  • OtherCheckingError.Builder.build()
                  • OtherCheckingError.Builder.message()
                  • OtherCheckingError.Builder.path()
                • OtherCheckingError.MESSAGE
                • OtherCheckingError.PATH
                • OtherCheckingError.TYPE_
                • OtherCheckingError.builder()
                • OtherCheckingError.message
                • OtherCheckingError.path
                • OtherCheckingError.with_message()
                • OtherCheckingError.with_path()
              • TypeArityMismatchError
                • TypeArityMismatchError.ACTUAL_ARITY
                • TypeArityMismatchError.Builder
                  • TypeArityMismatchError.Builder.actual_arity()
                  • TypeArityMismatchError.Builder.build()
                  • TypeArityMismatchError.Builder.expected_arity()
                  • TypeArityMismatchError.Builder.type()
                  • TypeArityMismatchError.Builder.type_arguments()
                • TypeArityMismatchError.EXPECTED_ARITY
                • TypeArityMismatchError.TYPE
                • TypeArityMismatchError.TYPE_
                • TypeArityMismatchError.TYPE_ARGUMENTS
                • TypeArityMismatchError.actual_arity
                • TypeArityMismatchError.builder()
                • TypeArityMismatchError.expected_arity
                • TypeArityMismatchError.type
                • TypeArityMismatchError.type_arguments
                • TypeArityMismatchError.with_actual_arity()
                • TypeArityMismatchError.with_expected_arity()
                • TypeArityMismatchError.with_type()
                • TypeArityMismatchError.with_type_arguments()
              • TypeMismatchError
                • TypeMismatchError.ACTUAL_TYPE
                • TypeMismatchError.Builder
                  • TypeMismatchError.Builder.actual_type()
                  • TypeMismatchError.Builder.build()
                  • TypeMismatchError.Builder.expected_type()
                • TypeMismatchError.EXPECTED_TYPE
                • TypeMismatchError.TYPE_
                • TypeMismatchError.actual_type
                • TypeMismatchError.builder()
                • TypeMismatchError.expected_type
                • TypeMismatchError.with_actual_type()
                • TypeMismatchError.with_expected_type()
              • UnboundTypeVariablesError
                • UnboundTypeVariablesError.Builder
                  • UnboundTypeVariablesError.Builder.build()
                  • UnboundTypeVariablesError.Builder.type()
                  • UnboundTypeVariablesError.Builder.variables()
                • UnboundTypeVariablesError.TYPE
                • UnboundTypeVariablesError.TYPE_
                • UnboundTypeVariablesError.VARIABLES
                • UnboundTypeVariablesError.builder()
                • UnboundTypeVariablesError.type
                • UnboundTypeVariablesError.variables
                • UnboundTypeVariablesError.with_type()
                • UnboundTypeVariablesError.with_variables()
              • UndefinedTermVariableCheckingError
                • UndefinedTermVariableCheckingError.Builder
                  • UndefinedTermVariableCheckingError.Builder.build()
                  • UndefinedTermVariableCheckingError.Builder.name()
                  • UndefinedTermVariableCheckingError.Builder.path()
                • UndefinedTermVariableCheckingError.NAME
                • UndefinedTermVariableCheckingError.PATH
                • UndefinedTermVariableCheckingError.TYPE_
                • UndefinedTermVariableCheckingError.builder()
                • UndefinedTermVariableCheckingError.name
                • UndefinedTermVariableCheckingError.path
                • UndefinedTermVariableCheckingError.with_name()
                • UndefinedTermVariableCheckingError.with_path()
              • UnequalTypesError
                • UnequalTypesError.Builder
                  • UnequalTypesError.Builder.build()
                  • UnequalTypesError.Builder.description()
                  • UnequalTypesError.Builder.types()
                • UnequalTypesError.DESCRIPTION
                • UnequalTypesError.TYPES
                • UnequalTypesError.TYPE_
                • UnequalTypesError.builder()
                • UnequalTypesError.description
                • UnequalTypesError.types
                • UnequalTypesError.with_description()
                • UnequalTypesError.with_types()
              • UnsupportedTermVariantError
                • UnsupportedTermVariantError.Builder
                  • UnsupportedTermVariantError.Builder.build()
                  • UnsupportedTermVariantError.Builder.term_variant()
                • UnsupportedTermVariantError.TERM_VARIANT
                • UnsupportedTermVariantError.TYPE_
                • UnsupportedTermVariantError.builder()
                • UnsupportedTermVariantError.term_variant
                • UnsupportedTermVariantError.with_term_variant()
              • UntypedLambdaError
                • UntypedLambdaError.Builder
                  • UntypedLambdaError.Builder.build()
                • UntypedLambdaError.TYPE_
                • UntypedLambdaError.builder()
              • UntypedLetBindingError
                • UntypedLetBindingError.BINDING
                • UntypedLetBindingError.Builder
                  • UntypedLetBindingError.Builder.binding()
                  • UntypedLetBindingError.Builder.build()
                • UntypedLetBindingError.TYPE_
                • UntypedLetBindingError.binding
                • UntypedLetBindingError.builder()
                • UntypedLetBindingError.with_binding()
              • UntypedTermVariableCheckingError
                • UntypedTermVariableCheckingError.Builder
                  • UntypedTermVariableCheckingError.Builder.build()
                  • UntypedTermVariableCheckingError.Builder.name()
                  • UntypedTermVariableCheckingError.Builder.path()
                • UntypedTermVariableCheckingError.NAME
                • UntypedTermVariableCheckingError.PATH
                • UntypedTermVariableCheckingError.TYPE_
                • UntypedTermVariableCheckingError.builder()
                • UntypedTermVariableCheckingError.name
                • UntypedTermVariableCheckingError.path
                • UntypedTermVariableCheckingError.with_name()
                • UntypedTermVariableCheckingError.with_path()
            • hydra.error.core module
              • ConstantConditionError
                • ConstantConditionError.Builder
                  • ConstantConditionError.Builder.build()
                  • ConstantConditionError.Builder.location()
                  • ConstantConditionError.Builder.value()
                • ConstantConditionError.LOCATION
                • ConstantConditionError.TYPE_
                • ConstantConditionError.VALUE
                • ConstantConditionError.builder()
                • ConstantConditionError.location
                • ConstantConditionError.value
                • ConstantConditionError.with_location()
                • ConstantConditionError.with_value()
              • DuplicateBindingError
                • DuplicateBindingError.Builder
                  • DuplicateBindingError.Builder.build()
                  • DuplicateBindingError.Builder.location()
                  • DuplicateBindingError.Builder.name()
                • DuplicateBindingError.LOCATION
                • DuplicateBindingError.NAME
                • DuplicateBindingError.TYPE_
                • DuplicateBindingError.builder()
                • DuplicateBindingError.location
                • DuplicateBindingError.name
                • DuplicateBindingError.with_location()
                • DuplicateBindingError.with_name()
              • DuplicateFieldError
                • DuplicateFieldError.Builder
                  • DuplicateFieldError.Builder.build()
                  • DuplicateFieldError.Builder.location()
                  • DuplicateFieldError.Builder.name()
                • DuplicateFieldError.LOCATION
                • DuplicateFieldError.NAME
                • DuplicateFieldError.TYPE_
                • DuplicateFieldError.builder()
                • DuplicateFieldError.location
                • DuplicateFieldError.name
                • DuplicateFieldError.with_location()
                • DuplicateFieldError.with_name()
              • DuplicateRecordTypeFieldNamesError
                • DuplicateRecordTypeFieldNamesError.Builder
                  • DuplicateRecordTypeFieldNamesError.Builder.build()
                  • DuplicateRecordTypeFieldNamesError.Builder.location()
                  • DuplicateRecordTypeFieldNamesError.Builder.name()
                • DuplicateRecordTypeFieldNamesError.LOCATION
                • DuplicateRecordTypeFieldNamesError.NAME
                • DuplicateRecordTypeFieldNamesError.TYPE_
                • DuplicateRecordTypeFieldNamesError.builder()
                • DuplicateRecordTypeFieldNamesError.location
                • DuplicateRecordTypeFieldNamesError.name
                • DuplicateRecordTypeFieldNamesError.with_location()
                • DuplicateRecordTypeFieldNamesError.with_name()
              • DuplicateUnionTypeFieldNamesError
                • DuplicateUnionTypeFieldNamesError.Builder
                  • DuplicateUnionTypeFieldNamesError.Builder.build()
                  • DuplicateUnionTypeFieldNamesError.Builder.location()
                  • DuplicateUnionTypeFieldNamesError.Builder.name()
                • DuplicateUnionTypeFieldNamesError.LOCATION
                • DuplicateUnionTypeFieldNamesError.NAME
                • DuplicateUnionTypeFieldNamesError.TYPE_
                • DuplicateUnionTypeFieldNamesError.builder()
                • DuplicateUnionTypeFieldNamesError.location
                • DuplicateUnionTypeFieldNamesError.name
                • DuplicateUnionTypeFieldNamesError.with_location()
                • DuplicateUnionTypeFieldNamesError.with_name()
              • EmptyCaseStatementError
                • EmptyCaseStatementError.Builder
                  • EmptyCaseStatementError.Builder.build()
                  • EmptyCaseStatementError.Builder.location()
                  • EmptyCaseStatementError.Builder.type_name()
                • EmptyCaseStatementError.LOCATION
                • EmptyCaseStatementError.TYPE_
                • EmptyCaseStatementError.TYPE_NAME
                • EmptyCaseStatementError.builder()
                • EmptyCaseStatementError.location
                • EmptyCaseStatementError.type_name
                • EmptyCaseStatementError.with_location()
                • EmptyCaseStatementError.with_type_name()
              • EmptyLetBindingsError
                • EmptyLetBindingsError.Builder
                  • EmptyLetBindingsError.Builder.build()
                  • EmptyLetBindingsError.Builder.location()
                • EmptyLetBindingsError.LOCATION
                • EmptyLetBindingsError.TYPE_
                • EmptyLetBindingsError.builder()
                • EmptyLetBindingsError.location
                • EmptyLetBindingsError.with_location()
              • EmptyRecordTypeError
                • EmptyRecordTypeError.Builder
                  • EmptyRecordTypeError.Builder.build()
                  • EmptyRecordTypeError.Builder.location()
                • EmptyRecordTypeError.LOCATION
                • EmptyRecordTypeError.TYPE_
                • EmptyRecordTypeError.builder()
                • EmptyRecordTypeError.location
                • EmptyRecordTypeError.with_location()
              • EmptyTermAnnotationError
                • EmptyTermAnnotationError.Builder
                  • EmptyTermAnnotationError.Builder.build()
                  • EmptyTermAnnotationError.Builder.location()
                • EmptyTermAnnotationError.LOCATION
                • EmptyTermAnnotationError.TYPE_
                • EmptyTermAnnotationError.builder()
                • EmptyTermAnnotationError.location
                • EmptyTermAnnotationError.with_location()
              • EmptyTypeAnnotationError
                • EmptyTypeAnnotationError.Builder
                  • EmptyTypeAnnotationError.Builder.build()
                  • EmptyTypeAnnotationError.Builder.location()
                • EmptyTypeAnnotationError.LOCATION
                • EmptyTypeAnnotationError.TYPE_
                • EmptyTypeAnnotationError.builder()
                • EmptyTypeAnnotationError.location
                • EmptyTypeAnnotationError.with_location()
              • EmptyTypeNameInTermError
                • EmptyTypeNameInTermError.Builder
                  • EmptyTypeNameInTermError.Builder.build()
                  • EmptyTypeNameInTermError.Builder.location()
                • EmptyTypeNameInTermError.LOCATION
                • EmptyTypeNameInTermError.TYPE_
                • EmptyTypeNameInTermError.builder()
                • EmptyTypeNameInTermError.location
                • EmptyTypeNameInTermError.with_location()
              • EmptyUnionTypeError
                • EmptyUnionTypeError.Builder
                  • EmptyUnionTypeError.Builder.build()
                  • EmptyUnionTypeError.Builder.location()
                • EmptyUnionTypeError.LOCATION
                • EmptyUnionTypeError.TYPE_
                • EmptyUnionTypeError.builder()
                • EmptyUnionTypeError.location
                • EmptyUnionTypeError.with_location()
              • ExtraRecordFieldsError
                • ExtraRecordFieldsError.Builder
                  • ExtraRecordFieldsError.Builder.build()
                  • ExtraRecordFieldsError.Builder.field_names()
                  • ExtraRecordFieldsError.Builder.location()
                  • ExtraRecordFieldsError.Builder.type_name()
                • ExtraRecordFieldsError.FIELD_NAMES
                • ExtraRecordFieldsError.LOCATION
                • ExtraRecordFieldsError.TYPE_
                • ExtraRecordFieldsError.TYPE_NAME
                • ExtraRecordFieldsError.builder()
                • ExtraRecordFieldsError.field_names
                • ExtraRecordFieldsError.location
                • ExtraRecordFieldsError.type_name
                • ExtraRecordFieldsError.with_field_names()
                • ExtraRecordFieldsError.with_location()
                • ExtraRecordFieldsError.with_type_name()
              • InvalidForallParameterNameError
                • InvalidForallParameterNameError.Builder
                  • InvalidForallParameterNameError.Builder.build()
                  • InvalidForallParameterNameError.Builder.location()
                  • InvalidForallParameterNameError.Builder.name()
                • InvalidForallParameterNameError.LOCATION
                • InvalidForallParameterNameError.NAME
                • InvalidForallParameterNameError.TYPE_
                • InvalidForallParameterNameError.builder()
                • InvalidForallParameterNameError.location
                • InvalidForallParameterNameError.name
                • InvalidForallParameterNameError.with_location()
                • InvalidForallParameterNameError.with_name()
              • InvalidLambdaParameterNameError
                • InvalidLambdaParameterNameError.Builder
                  • InvalidLambdaParameterNameError.Builder.build()
                  • InvalidLambdaParameterNameError.Builder.location()
                  • InvalidLambdaParameterNameError.Builder.name()
                • InvalidLambdaParameterNameError.LOCATION
                • InvalidLambdaParameterNameError.NAME
                • InvalidLambdaParameterNameError.TYPE_
                • InvalidLambdaParameterNameError.builder()
                • InvalidLambdaParameterNameError.location
                • InvalidLambdaParameterNameError.name
                • InvalidLambdaParameterNameError.with_location()
                • InvalidLambdaParameterNameError.with_name()
              • InvalidLetBindingNameError
                • InvalidLetBindingNameError.Builder
                  • InvalidLetBindingNameError.Builder.build()
                  • InvalidLetBindingNameError.Builder.location()
                  • InvalidLetBindingNameError.Builder.name()
                • InvalidLetBindingNameError.LOCATION
                • InvalidLetBindingNameError.NAME
                • InvalidLetBindingNameError.TYPE_
                • InvalidLetBindingNameError.builder()
                • InvalidLetBindingNameError.location
                • InvalidLetBindingNameError.name
                • InvalidLetBindingNameError.with_location()
                • InvalidLetBindingNameError.with_name()
              • InvalidLiteralError
                • InvalidLiteralError.TYPE_
                • InvalidLiteralError.TYPE_MISMATCH
              • InvalidLiteralErrorTypeMismatch
              • InvalidTermError
                • InvalidTermError.CONSTANT_CONDITION
                • InvalidTermError.DUPLICATE_BINDING
                • InvalidTermError.DUPLICATE_FIELD
                • InvalidTermError.EMPTY_CASE_STATEMENT
                • InvalidTermError.EMPTY_LET_BINDINGS
                • InvalidTermError.EMPTY_TERM_ANNOTATION
                • InvalidTermError.EMPTY_TYPE_NAME_IN_TERM
                • InvalidTermError.EXTRA_RECORD_FIELDS
                • InvalidTermError.INVALID_LAMBDA_PARAMETER_NAME
                • InvalidTermError.INVALID_LET_BINDING_NAME
                • InvalidTermError.INVALID_TYPE_LAMBDA_PARAMETER_NAME
                • InvalidTermError.MISSING_CASE_BRANCHES
                • InvalidTermError.MISSING_RECORD_FIELDS
                • InvalidTermError.NESTED_TERM_ANNOTATION
                • InvalidTermError.NOMINAL_TYPE_KIND_MISMATCH
                • InvalidTermError.REDUNDANT_WRAP_UNWRAP
                • InvalidTermError.SELF_APPLICATION
                • InvalidTermError.TERM_VARIABLE_SHADOWING
                • InvalidTermError.TYPE_
                • InvalidTermError.TYPE_VARIABLE_SHADOWING_IN_TYPE_LAMBDA
                • InvalidTermError.UNDECLARED_VARIANT
                • InvalidTermError.UNDEFINED_TERM_VARIABLE
                • InvalidTermError.UNDEFINED_TYPE_VARIABLE_IN_BINDING_TYPE
                • InvalidTermError.UNDEFINED_TYPE_VARIABLE_IN_LAMBDA_DOMAIN
                • InvalidTermError.UNDEFINED_TYPE_VARIABLE_IN_TYPE_APPLICATION
                • InvalidTermError.UNKNOWN_CASE_ALTERNATIVE
                • InvalidTermError.UNKNOWN_PRIMITIVE_NAME
                • InvalidTermError.UNKNOWN_PROJECTED_FIELD
                • InvalidTermError.UNNECESSARY_IDENTITY_APPLICATION
                • InvalidTermError.UNRESOLVED_NOMINAL_TYPE
                • InvalidTermError.UNTYPED_TERM_VARIABLE
              • 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
                • InvalidTypeError.DUPLICATE_RECORD_TYPE_FIELD_NAMES
                • InvalidTypeError.DUPLICATE_UNION_TYPE_FIELD_NAMES
                • InvalidTypeError.EMPTY_RECORD_TYPE
                • InvalidTypeError.EMPTY_TYPE_ANNOTATION
                • InvalidTypeError.EMPTY_UNION_TYPE
                • InvalidTypeError.INVALID_FORALL_PARAMETER_NAME
                • InvalidTypeError.INVALID_TYPE_SCHEME_VARIABLE_NAME
                • InvalidTypeError.NESTED_TYPE_ANNOTATION
                • InvalidTypeError.NON_COMPARABLE_MAP_KEY_TYPE
                • InvalidTypeError.NON_COMPARABLE_SET_ELEMENT_TYPE
                • InvalidTypeError.SINGLE_VARIANT_UNION
                • InvalidTypeError.TYPE_
                • InvalidTypeError.TYPE_VARIABLE_SHADOWING_IN_FORALL
                • InvalidTypeError.UNDEFINED_TYPE_VARIABLE
                • InvalidTypeError.VOID_IN_NON_BOTTOM_POSITION
              • InvalidTypeErrorDuplicateRecordTypeFieldNames
              • InvalidTypeErrorDuplicateUnionTypeFieldNames
              • InvalidTypeErrorEmptyRecordType
              • InvalidTypeErrorEmptyTypeAnnotation
              • InvalidTypeErrorEmptyUnionType
              • InvalidTypeErrorInvalidForallParameterName
              • InvalidTypeErrorInvalidTypeSchemeVariableName
              • InvalidTypeErrorNestedTypeAnnotation
              • InvalidTypeErrorNonComparableMapKeyType
              • InvalidTypeErrorNonComparableSetElementType
              • InvalidTypeErrorSingleVariantUnion
              • InvalidTypeErrorTypeVariableShadowingInForall
              • InvalidTypeErrorUndefinedTypeVariable
              • InvalidTypeErrorVoidInNonBottomPosition
              • InvalidTypeLambdaParameterNameError
                • InvalidTypeLambdaParameterNameError.Builder
                  • InvalidTypeLambdaParameterNameError.Builder.build()
                  • InvalidTypeLambdaParameterNameError.Builder.location()
                  • InvalidTypeLambdaParameterNameError.Builder.name()
                • InvalidTypeLambdaParameterNameError.LOCATION
                • InvalidTypeLambdaParameterNameError.NAME
                • InvalidTypeLambdaParameterNameError.TYPE_
                • InvalidTypeLambdaParameterNameError.builder()
                • InvalidTypeLambdaParameterNameError.location
                • InvalidTypeLambdaParameterNameError.name
                • InvalidTypeLambdaParameterNameError.with_location()
                • InvalidTypeLambdaParameterNameError.with_name()
              • InvalidTypeSchemeVariableNameError
                • InvalidTypeSchemeVariableNameError.Builder
                  • InvalidTypeSchemeVariableNameError.Builder.build()
                  • InvalidTypeSchemeVariableNameError.Builder.location()
                  • InvalidTypeSchemeVariableNameError.Builder.name()
                • InvalidTypeSchemeVariableNameError.LOCATION
                • InvalidTypeSchemeVariableNameError.NAME
                • InvalidTypeSchemeVariableNameError.TYPE_
                • InvalidTypeSchemeVariableNameError.builder()
                • InvalidTypeSchemeVariableNameError.location
                • InvalidTypeSchemeVariableNameError.name
                • InvalidTypeSchemeVariableNameError.with_location()
                • InvalidTypeSchemeVariableNameError.with_name()
              • LiteralTypeMismatchError
                • LiteralTypeMismatchError.ACTUAL_TYPE
                • LiteralTypeMismatchError.Builder
                  • LiteralTypeMismatchError.Builder.actual_type()
                  • LiteralTypeMismatchError.Builder.build()
                  • LiteralTypeMismatchError.Builder.expected_type()
                • LiteralTypeMismatchError.EXPECTED_TYPE
                • LiteralTypeMismatchError.TYPE_
                • LiteralTypeMismatchError.actual_type
                • LiteralTypeMismatchError.builder()
                • LiteralTypeMismatchError.expected_type
                • LiteralTypeMismatchError.with_actual_type()
                • LiteralTypeMismatchError.with_expected_type()
              • MissingCaseBranchesError
                • MissingCaseBranchesError.Builder
                  • MissingCaseBranchesError.Builder.build()
                  • MissingCaseBranchesError.Builder.location()
                  • MissingCaseBranchesError.Builder.type_name()
                  • MissingCaseBranchesError.Builder.variant_names()
                • MissingCaseBranchesError.LOCATION
                • MissingCaseBranchesError.TYPE_
                • MissingCaseBranchesError.TYPE_NAME
                • MissingCaseBranchesError.VARIANT_NAMES
                • MissingCaseBranchesError.builder()
                • MissingCaseBranchesError.location
                • MissingCaseBranchesError.type_name
                • MissingCaseBranchesError.variant_names
                • MissingCaseBranchesError.with_location()
                • MissingCaseBranchesError.with_type_name()
                • MissingCaseBranchesError.with_variant_names()
              • MissingRecordFieldsError
                • MissingRecordFieldsError.Builder
                  • MissingRecordFieldsError.Builder.build()
                  • MissingRecordFieldsError.Builder.field_names()
                  • MissingRecordFieldsError.Builder.location()
                  • MissingRecordFieldsError.Builder.type_name()
                • MissingRecordFieldsError.FIELD_NAMES
                • MissingRecordFieldsError.LOCATION
                • MissingRecordFieldsError.TYPE_
                • MissingRecordFieldsError.TYPE_NAME
                • MissingRecordFieldsError.builder()
                • MissingRecordFieldsError.field_names
                • MissingRecordFieldsError.location
                • MissingRecordFieldsError.type_name
                • MissingRecordFieldsError.with_field_names()
                • MissingRecordFieldsError.with_location()
                • MissingRecordFieldsError.with_type_name()
              • NestedTermAnnotationError
                • NestedTermAnnotationError.Builder
                  • NestedTermAnnotationError.Builder.build()
                  • NestedTermAnnotationError.Builder.location()
                • NestedTermAnnotationError.LOCATION
                • NestedTermAnnotationError.TYPE_
                • NestedTermAnnotationError.builder()
                • NestedTermAnnotationError.location
                • NestedTermAnnotationError.with_location()
              • NestedTypeAnnotationError
                • NestedTypeAnnotationError.Builder
                  • NestedTypeAnnotationError.Builder.build()
                  • NestedTypeAnnotationError.Builder.location()
                • NestedTypeAnnotationError.LOCATION
                • NestedTypeAnnotationError.TYPE_
                • NestedTypeAnnotationError.builder()
                • NestedTypeAnnotationError.location
                • NestedTypeAnnotationError.with_location()
              • NominalTypeKindMismatchError
                • NominalTypeKindMismatchError.ACTUAL_VARIANT
                • NominalTypeKindMismatchError.Builder
                  • NominalTypeKindMismatchError.Builder.actual_variant()
                  • NominalTypeKindMismatchError.Builder.build()
                  • NominalTypeKindMismatchError.Builder.expected_variant()
                  • NominalTypeKindMismatchError.Builder.location()
                  • NominalTypeKindMismatchError.Builder.type_name()
                • NominalTypeKindMismatchError.EXPECTED_VARIANT
                • NominalTypeKindMismatchError.LOCATION
                • NominalTypeKindMismatchError.TYPE_
                • NominalTypeKindMismatchError.TYPE_NAME
                • NominalTypeKindMismatchError.actual_variant
                • NominalTypeKindMismatchError.builder()
                • NominalTypeKindMismatchError.expected_variant
                • NominalTypeKindMismatchError.location
                • NominalTypeKindMismatchError.type_name
                • NominalTypeKindMismatchError.with_actual_variant()
                • NominalTypeKindMismatchError.with_expected_variant()
                • NominalTypeKindMismatchError.with_location()
                • NominalTypeKindMismatchError.with_type_name()
              • NonComparableMapKeyTypeError
                • NonComparableMapKeyTypeError.Builder
                  • NonComparableMapKeyTypeError.Builder.build()
                  • NonComparableMapKeyTypeError.Builder.key_type()
                  • NonComparableMapKeyTypeError.Builder.location()
                • NonComparableMapKeyTypeError.KEY_TYPE
                • NonComparableMapKeyTypeError.LOCATION
                • NonComparableMapKeyTypeError.TYPE_
                • NonComparableMapKeyTypeError.builder()
                • NonComparableMapKeyTypeError.key_type
                • NonComparableMapKeyTypeError.location
                • NonComparableMapKeyTypeError.with_key_type()
                • NonComparableMapKeyTypeError.with_location()
              • NonComparableSetElementTypeError
                • NonComparableSetElementTypeError.Builder
                  • NonComparableSetElementTypeError.Builder.build()
                  • NonComparableSetElementTypeError.Builder.element_type()
                  • NonComparableSetElementTypeError.Builder.location()
                • NonComparableSetElementTypeError.ELEMENT_TYPE
                • NonComparableSetElementTypeError.LOCATION
                • NonComparableSetElementTypeError.TYPE_
                • NonComparableSetElementTypeError.builder()
                • NonComparableSetElementTypeError.element_type
                • NonComparableSetElementTypeError.location
                • NonComparableSetElementTypeError.with_element_type()
                • NonComparableSetElementTypeError.with_location()
              • RedundantWrapUnwrapError
                • RedundantWrapUnwrapError.Builder
                  • RedundantWrapUnwrapError.Builder.build()
                  • RedundantWrapUnwrapError.Builder.location()
                  • RedundantWrapUnwrapError.Builder.type_name()
                • RedundantWrapUnwrapError.LOCATION
                • RedundantWrapUnwrapError.TYPE_
                • RedundantWrapUnwrapError.TYPE_NAME
                • RedundantWrapUnwrapError.builder()
                • RedundantWrapUnwrapError.location
                • RedundantWrapUnwrapError.type_name
                • RedundantWrapUnwrapError.with_location()
                • RedundantWrapUnwrapError.with_type_name()
              • SelfApplicationError
                • SelfApplicationError.Builder
                  • SelfApplicationError.Builder.build()
                  • SelfApplicationError.Builder.location()
                  • SelfApplicationError.Builder.name()
                • SelfApplicationError.LOCATION
                • SelfApplicationError.NAME
                • SelfApplicationError.TYPE_
                • SelfApplicationError.builder()
                • SelfApplicationError.location
                • SelfApplicationError.name
                • SelfApplicationError.with_location()
                • SelfApplicationError.with_name()
              • SingleVariantUnionError
                • SingleVariantUnionError.Builder
                  • SingleVariantUnionError.Builder.build()
                  • SingleVariantUnionError.Builder.field_name()
                  • SingleVariantUnionError.Builder.location()
                • SingleVariantUnionError.FIELD_NAME
                • SingleVariantUnionError.LOCATION
                • SingleVariantUnionError.TYPE_
                • SingleVariantUnionError.builder()
                • SingleVariantUnionError.field_name
                • SingleVariantUnionError.location
                • SingleVariantUnionError.with_field_name()
                • SingleVariantUnionError.with_location()
              • TermVariableShadowingError
                • TermVariableShadowingError.Builder
                  • TermVariableShadowingError.Builder.build()
                  • TermVariableShadowingError.Builder.location()
                  • TermVariableShadowingError.Builder.name()
                • TermVariableShadowingError.LOCATION
                • TermVariableShadowingError.NAME
                • TermVariableShadowingError.TYPE_
                • TermVariableShadowingError.builder()
                • TermVariableShadowingError.location
                • TermVariableShadowingError.name
                • TermVariableShadowingError.with_location()
                • TermVariableShadowingError.with_name()
              • TypeVariableShadowingInForallError
                • TypeVariableShadowingInForallError.Builder
                  • TypeVariableShadowingInForallError.Builder.build()
                  • TypeVariableShadowingInForallError.Builder.location()
                  • TypeVariableShadowingInForallError.Builder.name()
                • TypeVariableShadowingInForallError.LOCATION
                • TypeVariableShadowingInForallError.NAME
                • TypeVariableShadowingInForallError.TYPE_
                • TypeVariableShadowingInForallError.builder()
                • TypeVariableShadowingInForallError.location
                • TypeVariableShadowingInForallError.name
                • TypeVariableShadowingInForallError.with_location()
                • TypeVariableShadowingInForallError.with_name()
              • TypeVariableShadowingInTypeLambdaError
                • TypeVariableShadowingInTypeLambdaError.Builder
                  • TypeVariableShadowingInTypeLambdaError.Builder.build()
                  • TypeVariableShadowingInTypeLambdaError.Builder.location()
                  • TypeVariableShadowingInTypeLambdaError.Builder.name()
                • TypeVariableShadowingInTypeLambdaError.LOCATION
                • TypeVariableShadowingInTypeLambdaError.NAME
                • TypeVariableShadowingInTypeLambdaError.TYPE_
                • TypeVariableShadowingInTypeLambdaError.builder()
                • TypeVariableShadowingInTypeLambdaError.location
                • TypeVariableShadowingInTypeLambdaError.name
                • TypeVariableShadowingInTypeLambdaError.with_location()
                • TypeVariableShadowingInTypeLambdaError.with_name()
              • UndeclaredVariantError
                • UndeclaredVariantError.Builder
                  • UndeclaredVariantError.Builder.build()
                  • UndeclaredVariantError.Builder.location()
                  • UndeclaredVariantError.Builder.type_name()
                  • UndeclaredVariantError.Builder.variant_name()
                • UndeclaredVariantError.LOCATION
                • UndeclaredVariantError.TYPE_
                • UndeclaredVariantError.TYPE_NAME
                • UndeclaredVariantError.VARIANT_NAME
                • UndeclaredVariantError.builder()
                • UndeclaredVariantError.location
                • UndeclaredVariantError.type_name
                • UndeclaredVariantError.variant_name
                • UndeclaredVariantError.with_location()
                • UndeclaredVariantError.with_type_name()
                • UndeclaredVariantError.with_variant_name()
              • UndefinedFieldError
                • UndefinedFieldError.Builder
                  • UndefinedFieldError.Builder.build()
                  • UndefinedFieldError.Builder.field_name()
                  • UndefinedFieldError.Builder.type_name()
                • UndefinedFieldError.FIELD_NAME
                • UndefinedFieldError.TYPE_
                • UndefinedFieldError.TYPE_NAME
                • UndefinedFieldError.builder()
                • UndefinedFieldError.field_name
                • UndefinedFieldError.type_name
                • UndefinedFieldError.with_field_name()
                • UndefinedFieldError.with_type_name()
              • UndefinedTermVariableError
                • UndefinedTermVariableError.Builder
                  • UndefinedTermVariableError.Builder.build()
                  • UndefinedTermVariableError.Builder.location()
                  • UndefinedTermVariableError.Builder.name()
                • UndefinedTermVariableError.LOCATION
                • UndefinedTermVariableError.NAME
                • UndefinedTermVariableError.TYPE_
                • UndefinedTermVariableError.builder()
                • UndefinedTermVariableError.location
                • UndefinedTermVariableError.name
                • UndefinedTermVariableError.with_location()
                • UndefinedTermVariableError.with_name()
              • UndefinedTypeVariableError
                • UndefinedTypeVariableError.Builder
                  • UndefinedTypeVariableError.Builder.build()
                  • UndefinedTypeVariableError.Builder.location()
                  • UndefinedTypeVariableError.Builder.name()
                • UndefinedTypeVariableError.LOCATION
                • UndefinedTypeVariableError.NAME
                • UndefinedTypeVariableError.TYPE_
                • UndefinedTypeVariableError.builder()
                • UndefinedTypeVariableError.location
                • UndefinedTypeVariableError.name
                • UndefinedTypeVariableError.with_location()
                • UndefinedTypeVariableError.with_name()
              • UndefinedTypeVariableInBindingTypeError
                • UndefinedTypeVariableInBindingTypeError.Builder
                  • UndefinedTypeVariableInBindingTypeError.Builder.build()
                  • UndefinedTypeVariableInBindingTypeError.Builder.location()
                  • UndefinedTypeVariableInBindingTypeError.Builder.name()
                • UndefinedTypeVariableInBindingTypeError.LOCATION
                • UndefinedTypeVariableInBindingTypeError.NAME
                • UndefinedTypeVariableInBindingTypeError.TYPE_
                • UndefinedTypeVariableInBindingTypeError.builder()
                • UndefinedTypeVariableInBindingTypeError.location
                • UndefinedTypeVariableInBindingTypeError.name
                • UndefinedTypeVariableInBindingTypeError.with_location()
                • UndefinedTypeVariableInBindingTypeError.with_name()
              • UndefinedTypeVariableInLambdaDomainError
                • UndefinedTypeVariableInLambdaDomainError.Builder
                  • UndefinedTypeVariableInLambdaDomainError.Builder.build()
                  • UndefinedTypeVariableInLambdaDomainError.Builder.location()
                  • UndefinedTypeVariableInLambdaDomainError.Builder.name()
                • UndefinedTypeVariableInLambdaDomainError.LOCATION
                • UndefinedTypeVariableInLambdaDomainError.NAME
                • UndefinedTypeVariableInLambdaDomainError.TYPE_
                • UndefinedTypeVariableInLambdaDomainError.builder()
                • UndefinedTypeVariableInLambdaDomainError.location
                • UndefinedTypeVariableInLambdaDomainError.name
                • UndefinedTypeVariableInLambdaDomainError.with_location()
                • UndefinedTypeVariableInLambdaDomainError.with_name()
              • UndefinedTypeVariableInTypeApplicationError
                • UndefinedTypeVariableInTypeApplicationError.Builder
                  • UndefinedTypeVariableInTypeApplicationError.Builder.build()
                  • UndefinedTypeVariableInTypeApplicationError.Builder.location()
                  • UndefinedTypeVariableInTypeApplicationError.Builder.name()
                • UndefinedTypeVariableInTypeApplicationError.LOCATION
                • UndefinedTypeVariableInTypeApplicationError.NAME
                • UndefinedTypeVariableInTypeApplicationError.TYPE_
                • UndefinedTypeVariableInTypeApplicationError.builder()
                • UndefinedTypeVariableInTypeApplicationError.location
                • UndefinedTypeVariableInTypeApplicationError.name
                • UndefinedTypeVariableInTypeApplicationError.with_location()
                • UndefinedTypeVariableInTypeApplicationError.with_name()
              • UnexpectedTermVariantError
                • UnexpectedTermVariantError.ACTUAL_TERM
                • UnexpectedTermVariantError.Builder
                  • UnexpectedTermVariantError.Builder.actual_term()
                  • UnexpectedTermVariantError.Builder.build()
                  • UnexpectedTermVariantError.Builder.expected_variant()
                • UnexpectedTermVariantError.EXPECTED_VARIANT
                • UnexpectedTermVariantError.TYPE_
                • UnexpectedTermVariantError.actual_term
                • UnexpectedTermVariantError.builder()
                • UnexpectedTermVariantError.expected_variant
                • UnexpectedTermVariantError.with_actual_term()
                • UnexpectedTermVariantError.with_expected_variant()
              • UnexpectedTypeVariantError
                • UnexpectedTypeVariantError.ACTUAL_TYPE
                • UnexpectedTypeVariantError.Builder
                  • UnexpectedTypeVariantError.Builder.actual_type()
                  • UnexpectedTypeVariantError.Builder.build()
                  • UnexpectedTypeVariantError.Builder.expected_variant()
                • UnexpectedTypeVariantError.EXPECTED_VARIANT
                • UnexpectedTypeVariantError.TYPE_
                • UnexpectedTypeVariantError.actual_type
                • UnexpectedTypeVariantError.builder()
                • UnexpectedTypeVariantError.expected_variant
                • UnexpectedTypeVariantError.with_actual_type()
                • UnexpectedTypeVariantError.with_expected_variant()
              • UnknownCaseAlternativeError
                • UnknownCaseAlternativeError.Builder
                  • UnknownCaseAlternativeError.Builder.build()
                  • UnknownCaseAlternativeError.Builder.location()
                  • UnknownCaseAlternativeError.Builder.name()
                  • UnknownCaseAlternativeError.Builder.type_name()
                • UnknownCaseAlternativeError.LOCATION
                • UnknownCaseAlternativeError.NAME
                • UnknownCaseAlternativeError.TYPE_
                • UnknownCaseAlternativeError.TYPE_NAME
                • UnknownCaseAlternativeError.builder()
                • UnknownCaseAlternativeError.location
                • UnknownCaseAlternativeError.name
                • UnknownCaseAlternativeError.type_name
                • UnknownCaseAlternativeError.with_location()
                • UnknownCaseAlternativeError.with_name()
                • UnknownCaseAlternativeError.with_type_name()
              • UnknownPrimitiveNameError
                • UnknownPrimitiveNameError.Builder
                  • UnknownPrimitiveNameError.Builder.build()
                  • UnknownPrimitiveNameError.Builder.location()
                  • UnknownPrimitiveNameError.Builder.name()
                • UnknownPrimitiveNameError.LOCATION
                • UnknownPrimitiveNameError.NAME
                • UnknownPrimitiveNameError.TYPE_
                • UnknownPrimitiveNameError.builder()
                • UnknownPrimitiveNameError.location
                • UnknownPrimitiveNameError.name
                • UnknownPrimitiveNameError.with_location()
                • UnknownPrimitiveNameError.with_name()
              • UnknownProjectedFieldError
                • UnknownProjectedFieldError.Builder
                  • UnknownProjectedFieldError.Builder.build()
                  • UnknownProjectedFieldError.Builder.field_name()
                  • UnknownProjectedFieldError.Builder.location()
                  • UnknownProjectedFieldError.Builder.type_name()
                • UnknownProjectedFieldError.FIELD_NAME
                • UnknownProjectedFieldError.LOCATION
                • UnknownProjectedFieldError.TYPE_
                • UnknownProjectedFieldError.TYPE_NAME
                • UnknownProjectedFieldError.builder()
                • UnknownProjectedFieldError.field_name
                • UnknownProjectedFieldError.location
                • UnknownProjectedFieldError.type_name
                • UnknownProjectedFieldError.with_field_name()
                • UnknownProjectedFieldError.with_location()
                • UnknownProjectedFieldError.with_type_name()
              • UnnecessaryIdentityApplicationError
                • UnnecessaryIdentityApplicationError.Builder
                  • UnnecessaryIdentityApplicationError.Builder.build()
                  • UnnecessaryIdentityApplicationError.Builder.location()
                • UnnecessaryIdentityApplicationError.LOCATION
                • UnnecessaryIdentityApplicationError.TYPE_
                • UnnecessaryIdentityApplicationError.builder()
                • UnnecessaryIdentityApplicationError.location
                • UnnecessaryIdentityApplicationError.with_location()
              • UnresolvedNominalTypeError
                • UnresolvedNominalTypeError.Builder
                  • UnresolvedNominalTypeError.Builder.build()
                  • UnresolvedNominalTypeError.Builder.location()
                  • UnresolvedNominalTypeError.Builder.type_name()
                • UnresolvedNominalTypeError.LOCATION
                • UnresolvedNominalTypeError.TYPE_
                • UnresolvedNominalTypeError.TYPE_NAME
                • UnresolvedNominalTypeError.builder()
                • UnresolvedNominalTypeError.location
                • UnresolvedNominalTypeError.type_name
                • UnresolvedNominalTypeError.with_location()
                • UnresolvedNominalTypeError.with_type_name()
              • UntypedTermVariableError
                • UntypedTermVariableError.Builder
                  • UntypedTermVariableError.Builder.build()
                  • UntypedTermVariableError.Builder.location()
                  • UntypedTermVariableError.Builder.name()
                • UntypedTermVariableError.LOCATION
                • UntypedTermVariableError.NAME
                • UntypedTermVariableError.TYPE_
                • UntypedTermVariableError.builder()
                • UntypedTermVariableError.location
                • UntypedTermVariableError.name
                • UntypedTermVariableError.with_location()
                • UntypedTermVariableError.with_name()
              • VoidInNonBottomPositionError
                • VoidInNonBottomPositionError.Builder
                  • VoidInNonBottomPositionError.Builder.build()
                  • VoidInNonBottomPositionError.Builder.location()
                • VoidInNonBottomPositionError.LOCATION
                • VoidInNonBottomPositionError.TYPE_
                • VoidInNonBottomPositionError.builder()
                • VoidInNonBottomPositionError.location
                • VoidInNonBottomPositionError.with_location()
            • hydra.error.file module
              • FileError
                • FileError.ALREADY_EXISTS
                • FileError.INVALID_PATH
                • FileError.NOT_FOUND
                • FileError.OTHER
                • FileError.PERMISSION_DENIED
                • FileError.TYPE_
              • FileErrorAlreadyExists
              • FileErrorInvalidPath
              • FileErrorNotFound
              • FileErrorOther
              • FileErrorPermissionDenied
            • hydra.error.packaging module
              • ConflictingModuleNameError
                • ConflictingModuleNameError.Builder
                  • ConflictingModuleNameError.Builder.build()
                  • ConflictingModuleNameError.Builder.first()
                  • ConflictingModuleNameError.Builder.second()
                • ConflictingModuleNameError.FIRST
                • ConflictingModuleNameError.SECOND
                • ConflictingModuleNameError.TYPE_
                • ConflictingModuleNameError.builder()
                • ConflictingModuleNameError.first
                • ConflictingModuleNameError.second
                • ConflictingModuleNameError.with_first()
                • ConflictingModuleNameError.with_second()
              • ConflictingVariantNameError
                • ConflictingVariantNameError.Builder
                  • ConflictingVariantNameError.Builder.build()
                  • ConflictingVariantNameError.Builder.conflicting_name()
                  • ConflictingVariantNameError.Builder.module_name()
                  • ConflictingVariantNameError.Builder.type_name()
                  • ConflictingVariantNameError.Builder.variant_name()
                • ConflictingVariantNameError.CONFLICTING_NAME
                • ConflictingVariantNameError.MODULE_NAME
                • ConflictingVariantNameError.TYPE_
                • ConflictingVariantNameError.TYPE_NAME
                • ConflictingVariantNameError.VARIANT_NAME
                • ConflictingVariantNameError.builder()
                • ConflictingVariantNameError.conflicting_name
                • ConflictingVariantNameError.module_name
                • ConflictingVariantNameError.type_name
                • ConflictingVariantNameError.variant_name
                • ConflictingVariantNameError.with_conflicting_name()
                • ConflictingVariantNameError.with_module_name()
                • ConflictingVariantNameError.with_type_name()
                • ConflictingVariantNameError.with_variant_name()
              • DefinitionNotInModuleNameError
                • DefinitionNotInModuleNameError.Builder
                  • DefinitionNotInModuleNameError.Builder.build()
                  • DefinitionNotInModuleNameError.Builder.module_name()
                  • DefinitionNotInModuleNameError.Builder.name()
                • DefinitionNotInModuleNameError.MODULE_NAME
                • DefinitionNotInModuleNameError.NAME
                • DefinitionNotInModuleNameError.TYPE_
                • DefinitionNotInModuleNameError.builder()
                • DefinitionNotInModuleNameError.module_name
                • DefinitionNotInModuleNameError.name
                • DefinitionNotInModuleNameError.with_module_name()
                • DefinitionNotInModuleNameError.with_name()
              • DefinitionsOutOfOrderError
                • DefinitionsOutOfOrderError.Builder
                  • DefinitionsOutOfOrderError.Builder.build()
                  • DefinitionsOutOfOrderError.Builder.following_name()
                  • DefinitionsOutOfOrderError.Builder.module_name()
                  • DefinitionsOutOfOrderError.Builder.preceding_name()
                • DefinitionsOutOfOrderError.FOLLOWING_NAME
                • DefinitionsOutOfOrderError.MODULE_NAME
                • DefinitionsOutOfOrderError.PRECEDING_NAME
                • DefinitionsOutOfOrderError.TYPE_
                • DefinitionsOutOfOrderError.builder()
                • DefinitionsOutOfOrderError.following_name
                • DefinitionsOutOfOrderError.module_name
                • DefinitionsOutOfOrderError.preceding_name
                • DefinitionsOutOfOrderError.with_following_name()
                • DefinitionsOutOfOrderError.with_module_name()
                • DefinitionsOutOfOrderError.with_preceding_name()
              • DuplicateDefinitionNameError
                • DuplicateDefinitionNameError.Builder
                  • DuplicateDefinitionNameError.Builder.build()
                  • DuplicateDefinitionNameError.Builder.module_name()
                  • DuplicateDefinitionNameError.Builder.name()
                • DuplicateDefinitionNameError.MODULE_NAME
                • DuplicateDefinitionNameError.NAME
                • DuplicateDefinitionNameError.TYPE_
                • DuplicateDefinitionNameError.builder()
                • DuplicateDefinitionNameError.module_name
                • DuplicateDefinitionNameError.name
                • DuplicateDefinitionNameError.with_module_name()
                • DuplicateDefinitionNameError.with_name()
              • DuplicateModuleNameError
                • DuplicateModuleNameError.Builder
                  • DuplicateModuleNameError.Builder.build()
                  • DuplicateModuleNameError.Builder.module_name()
                • DuplicateModuleNameError.MODULE_NAME
                • DuplicateModuleNameError.TYPE_
                • DuplicateModuleNameError.builder()
                • DuplicateModuleNameError.module_name
                • DuplicateModuleNameError.with_module_name()
              • InvalidDefinitionNameError
                • InvalidDefinitionNameError.Builder
                  • InvalidDefinitionNameError.Builder.build()
                  • InvalidDefinitionNameError.Builder.expected_convention()
                  • InvalidDefinitionNameError.Builder.module_name()
                  • InvalidDefinitionNameError.Builder.name()
                • InvalidDefinitionNameError.EXPECTED_CONVENTION
                • InvalidDefinitionNameError.MODULE_NAME
                • InvalidDefinitionNameError.NAME
                • InvalidDefinitionNameError.TYPE_
                • InvalidDefinitionNameError.builder()
                • InvalidDefinitionNameError.expected_convention
                • InvalidDefinitionNameError.module_name
                • InvalidDefinitionNameError.name
                • InvalidDefinitionNameError.with_expected_convention()
                • InvalidDefinitionNameError.with_module_name()
                • InvalidDefinitionNameError.with_name()
              • InvalidModuleError
                • InvalidModuleError.CONFLICTING_VARIANT_NAME
                • InvalidModuleError.DEFINITIONS_OUT_OF_ORDER
                • InvalidModuleError.DEFINITION_NOT_IN_MODULE_NAME
                • InvalidModuleError.DUPLICATE_DEFINITION_NAME
                • InvalidModuleError.INVALID_DEFINITION_NAME
                • InvalidModuleError.INVALID_MODULE_NAME_CONVENTION
                • InvalidModuleError.MISSING_DOCUMENTATION
                • InvalidModuleError.TYPE_
              • InvalidModuleErrorConflictingVariantName
              • InvalidModuleErrorDefinitionNotInModuleName
              • InvalidModuleErrorDefinitionsOutOfOrder
              • InvalidModuleErrorDuplicateDefinitionName
              • InvalidModuleErrorInvalidDefinitionName
              • InvalidModuleErrorInvalidModuleNameConvention
              • InvalidModuleErrorMissingDocumentation
              • InvalidModuleNameConventionError
                • InvalidModuleNameConventionError.Builder
                  • InvalidModuleNameConventionError.Builder.build()
                  • InvalidModuleNameConventionError.Builder.module_name()
                • InvalidModuleNameConventionError.MODULE_NAME
                • InvalidModuleNameConventionError.TYPE_
                • InvalidModuleNameConventionError.builder()
                • InvalidModuleNameConventionError.module_name
                • InvalidModuleNameConventionError.with_module_name()
              • InvalidPackageError
                • InvalidPackageError.CONFLICTING_MODULE_NAME
                • InvalidPackageError.DUPLICATE_MODULE_NAME
                • InvalidPackageError.INVALID_MODULE
                • InvalidPackageError.INVALID_PACKAGE_NAME
                • InvalidPackageError.TYPE_
                • InvalidPackageError.UNDECLARED_DEPENDENCY
              • InvalidPackageErrorConflictingModuleName
              • InvalidPackageErrorDuplicateModuleName
              • InvalidPackageErrorInvalidModule
              • InvalidPackageErrorInvalidPackageName
              • InvalidPackageErrorUndeclaredDependency
              • InvalidPackageNameError
                • InvalidPackageNameError.Builder
                  • InvalidPackageNameError.Builder.build()
                  • InvalidPackageNameError.Builder.package_name()
                • InvalidPackageNameError.PACKAGE_NAME
                • InvalidPackageNameError.TYPE_
                • InvalidPackageNameError.builder()
                • InvalidPackageNameError.package_name
                • InvalidPackageNameError.with_package_name()
              • MissingDocumentationError
                • MissingDocumentationError.Builder
                  • MissingDocumentationError.Builder.build()
                  • MissingDocumentationError.Builder.module_name()
                  • MissingDocumentationError.Builder.name()
                • MissingDocumentationError.MODULE_NAME
                • MissingDocumentationError.NAME
                • MissingDocumentationError.TYPE_
                • MissingDocumentationError.builder()
                • MissingDocumentationError.module_name
                • MissingDocumentationError.name
                • MissingDocumentationError.with_module_name()
                • MissingDocumentationError.with_name()
              • UndeclaredDependencyError
                • UndeclaredDependencyError.Builder
                  • UndeclaredDependencyError.Builder.build()
                  • UndeclaredDependencyError.Builder.module_name()
                  • UndeclaredDependencyError.Builder.owning_module_name()
                  • UndeclaredDependencyError.Builder.referenced_name()
                • UndeclaredDependencyError.MODULE_NAME
                • UndeclaredDependencyError.OWNING_MODULE_NAME
                • UndeclaredDependencyError.REFERENCED_NAME
                • UndeclaredDependencyError.TYPE_
                • UndeclaredDependencyError.builder()
                • UndeclaredDependencyError.module_name
                • UndeclaredDependencyError.owning_module_name
                • UndeclaredDependencyError.referenced_name
                • UndeclaredDependencyError.with_module_name()
                • UndeclaredDependencyError.with_owning_module_name()
                • UndeclaredDependencyError.with_referenced_name()
            • hydra.error.system module
              • SystemError
                • SystemError.COMMAND_NOT_FOUND
                • SystemError.INTERRUPTED
                • SystemError.INVALID_WORKING_DIRECTORY
                • SystemError.OTHER
                • SystemError.PERMISSION_DENIED
                • SystemError.TYPE_
              • 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
                • hydra.json.yaml.decode module
                  • from_yaml()
                  • yaml_to_json()
                • hydra.json.yaml.encode module
                  • json_to_yaml()
                  • to_yaml()
          • 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
                • Value.ARRAY
                • Value.BOOLEAN
                • Value.NULL
                • Value.NUMBER
                • Value.OBJECT
                • Value.STRING
                • Value.TYPE_
              • 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
                • hydra.overlay.python.dsl package
                  • Subpackages
                    • hydra.overlay.python.dsl.meta package
                      • Submodules
                        • hydra.overlay.python.dsl.meta.core module
                          • equal_name()
                          • equal_name_list()
                          • false_term()
                          • field_type_with_type_value()
                          • field_with_term_value()
                          • float_type_float32()
                          • float_type_float64()
                          • int32_term()
                          • integer_type_bigint()
                          • integer_type_int16()
                          • integer_type_int32()
                          • integer_type_int64()
                          • integer_type_int8()
                          • integer_type_uint16()
                          • integer_type_uint32()
                          • integer_type_uint64()
                          • integer_type_uint8()
                          • let_()
                          • literal_type_binary()
                          • literal_type_boolean()
                          • literal_type_string()
                          • name_lift()
                          • string_term()
                          • term_unit()
                          • type_unit()
                          • un_namespace()
                        • hydra.overlay.python.dsl.meta.defs module
                          • check_complete()
                        • hydra.overlay.python.dsl.meta.graph module
                          • comparison_equal_to()
                          • comparison_greater_than()
                          • comparison_less_than()
                          • empty_graph()
                          • graph_primitive_types()
                        • hydra.overlay.python.dsl.meta.phantom_literals module
                          • bigint()
                          • binary()
                          • boolean()
                          • char()
                          • decimal()
                          • double()
                          • false()
                          • float32()
                          • float64()
                          • float_()
                          • int16()
                          • int32()
                          • int64()
                          • int8()
                          • int_()
                          • integer()
                          • string()
                          • true()
                          • uint16()
                          • uint32()
                          • uint64()
                          • uint8()
                        • hydra.overlay.python.dsl.meta.phantoms module
                          • annot()
                          • apply()
                          • binary_function()
                          • bindings()
                          • cases()
                          • compose()
                          • constant()
                          • definition_in_module()
                          • definition_in_namespace()
                          • derive_primitive_name()
                          • doc()
                          • doc_wrapped()
                          • el()
                          • field()
                          • field_name_op()
                          • field_op()
                          • first()
                          • first_class_type()
                          • fold()
                          • identity()
                          • inject()
                          • inject_lambda()
                          • inject_unit()
                          • just()
                          • just_()
                          • lam()
                          • lambdas()
                          • left()
                          • left_()
                          • let()
                          • let1()
                          • let_chain()
                          • lets()
                          • lib_primitive()
                          • lib_primitive1()
                          • lib_primitive2()
                          • lib_primitive3()
                          • list_()
                          • make_local()
                          • map_()
                          • match()
                          • match_with_default()
                          • module_name()
                          • nothing()
                          • opt()
                          • opt_cases()
                          • pair()
                          • primitive()
                          • primitive1()
                          • primitive2()
                          • primitive3()
                          • project()
                          • record()
                          • ref()
                          • right()
                          • right_()
                          • second()
                          • set_()
                          • to_binding()
                          • to_definition()
                          • to_term_definition()
                          • triple()
                          • tuple4()
                          • tuple5()
                          • un_tterm()
                          • unary_function()
                          • unit()
                          • unqualify_name()
                          • unsafe_cast()
                          • unwrap()
                          • var()
                          • with_eq()
                          • with_ord()
                          • with_type_classes()
                          • wrap()
                      • Module contents
                    • hydra.overlay.python.dsl.python package
                      • Module contents
                        • Either
                        • FrozenDict
                          • FrozenDict.copy()
                          • FrozenDict.data
                        • Given
                          • Given.value
                        • Left
                          • Left.value
                        • Node
                          • Node.value
                        • None_
                        • Optional
                        • Right
                          • Right.value
                        • freeze()
                        • frozenlist
                        • unsupported()
                  • Submodules
                    • hydra.overlay.python.dsl.annotations module
                      • annotate_term()
                      • annotate_type()
                      • bounded()
                      • bounded_list()
                      • bounded_map()
                      • bounded_set()
                      • bounded_string()
                      • data_doc()
                      • deprecated()
                      • doc()
                      • doc70()
                      • doc80()
                      • exclude()
                      • min_length_list()
                      • nonempty_list()
                      • nonempty_map()
                      • note()
                      • preserve_field_name()
                      • see()
                      • set_max_length()
                      • set_min_length()
                      • set_term_annotation()
                      • set_term_description()
                      • set_type_annotation()
                      • set_type_description()
                      • two_or_more_list()
                      • wrap_line()
                    • hydra.overlay.python.dsl.literal_types module
                      • bigint()
                      • binary()
                      • boolean()
                      • decimal()
                      • float32()
                      • float64()
                      • float_()
                      • int16()
                      • int32()
                      • int64()
                      • int8()
                      • integer()
                      • show_literal_type()
                      • string()
                      • uint16()
                      • uint32()
                      • uint64()
                      • uint8()
                    • hydra.overlay.python.dsl.literals module
                      • bigint()
                      • binary()
                      • boolean()
                      • decimal()
                      • float32()
                      • float64()
                      • float_()
                      • int16()
                      • int32()
                      • int64()
                      • int8()
                      • integer()
                      • string()
                      • uint16()
                      • uint32()
                      • uint64()
                      • uint8()
                    • hydra.overlay.python.dsl.prims module
                      • TypeVar_
                      • bigint()
                      • binary()
                      • boolean()
                      • build_type_scheme()
                      • comparison()
                      • decimal()
                      • default_fallback_primitive()
                      • default_primitive_definition()
                      • either()
                      • float32()
                      • float64()
                      • float_type()
                      • float_value()
                      • function()
                      • function_with_reduce()
                      • int16()
                      • int32()
                      • int64()
                      • int8()
                      • integer_type()
                      • integer_value()
                      • list_()
                      • literal()
                      • literal_type()
                      • map_()
                      • optional()
                      • other_err()
                      • pair()
                      • prim0()
                      • prim1()
                      • prim2()
                      • prim3()
                      • set_()
                      • string()
                      • term()
                      • type_()
                      • type_var_names()
                      • type_vars_to_constraints()
                      • uint16()
                      • uint32()
                      • uint64()
                      • uint8()
                      • v()
                      • v_eq()
                      • v_frac()
                      • v_integral()
                      • v_num()
                      • v_ord()
                      • variable()
                      • void()
                    • hydra.overlay.python.dsl.terms module
                      • annot()
                      • annotated()
                      • annotation_map_as_term()
                      • apply()
                      • apply_all()
                      • bigint()
                      • binary()
                      • boolean()
                      • char()
                      • comparison()
                      • compose()
                      • constant()
                      • decimal()
                      • false()
                      • field()
                      • fields_to_map()
                      • first()
                      • float32()
                      • float64()
                      • float_()
                      • identity()
                      • inject()
                      • inject_unit()
                      • int16()
                      • int32()
                      • int64()
                      • int8()
                      • integer()
                      • just()
                      • lambda_()
                      • lambda_typed()
                      • lambdas()
                      • left()
                      • let_multi()
                      • let_term()
                      • lets()
                      • lets_typed()
                      • list_()
                      • literal()
                      • map_()
                      • map_term()
                      • match()
                      • match_with_variants()
                      • nothing()
                      • optional()
                      • pair()
                      • primitive()
                      • project()
                      • record()
                      • right()
                      • second()
                      • set_()
                      • string()
                      • triple()
                      • true()
                      • tuple2()
                      • tuple3()
                      • tuple4()
                      • tuple5()
                      • tuple_()
                      • tyapp()
                      • tyapps()
                      • tylam()
                      • tylams()
                      • type_application()
                      • type_lambda()
                      • uint16()
                      • uint32()
                      • uint64()
                      • uint8()
                      • unit()
                      • unwrap()
                      • var()
                      • with_variant()
                      • wrap()
                    • hydra.overlay.python.dsl.types module
                      • annot()
                      • apply()
                      • apply_many()
                      • applys()
                      • bigint()
                      • binary()
                      • boolean()
                      • decimal()
                      • either()
                      • enum()
                      • field()
                      • float32()
                      • float64()
                      • float_()
                      • forall()
                      • foralls()
                      • function()
                      • function_many()
                      • int16()
                      • int32()
                      • int64()
                      • int8()
                      • integer()
                      • list_()
                      • literal()
                      • map_()
                      • maybe()
                      • mono()
                      • non_negative_int32()
                      • optional()
                      • pair()
                      • poly()
                      • poly_constrained()
                      • product()
                      • record()
                      • record_with_name()
                      • set_()
                      • string()
                      • uint16()
                      • uint32()
                      • uint64()
                      • uint8()
                      • union()
                      • unit()
                      • use()
                      • var()
                      • variable()
                      • void()
                      • wrap()
                      • wrap_with_name()
                  • Module contents
                • hydra.overlay.python.lib package
                  • Submodules
                    • hydra.overlay.python.lib.chars module
                      • is_alpha_num()
                      • is_lower()
                      • is_space()
                      • is_upper()
                      • to_lower()
                      • to_upper()
                    • hydra.overlay.python.lib.effects module
                      • apply()
                      • bind()
                      • compose()
                      • fold_list()
                      • map()
                      • map_list()
                      • map_optional()
                      • pure()
                    • hydra.overlay.python.lib.eithers module
                      • bimap()
                      • bind()
                      • either()
                      • fold_list()
                      • from_left()
                      • from_right()
                      • is_left()
                      • is_right()
                      • left()
                      • lefts()
                      • map()
                      • map_left()
                      • map_list()
                      • map_optional()
                      • map_right()
                      • map_set()
                      • partition()
                      • right()
                      • rights()
                    • hydra.overlay.python.lib.equality module
                      • equal()
                    • hydra.overlay.python.lib.files module
                      • append_file()
                      • copy()
                      • create_directory()
                      • create_symlink()
                      • exists()
                      • list_directory()
                      • read_file()
                      • read_symlink()
                      • remove_directory()
                      • remove_file()
                      • rename()
                      • status()
                      • write_file()
                    • hydra.overlay.python.lib.functions module
                      • absurd()
                      • identity()
                    • hydra.overlay.python.lib.hashing module
                      • sha256()
                      • sha256_hex()
                    • hydra.overlay.python.lib.lists module
                      • apply()
                      • at()
                      • bind()
                      • concat()
                      • concat2()
                      • cons()
                      • distinct()
                      • drop()
                      • drop_while()
                      • filter()
                      • find()
                      • foldl()
                      • foldr()
                      • group()
                      • head()
                      • init()
                      • intersperse()
                      • is_empty()
                      • join()
                      • last()
                      • length()
                      • map()
                      • member()
                      • partition()
                      • replicate()
                      • reverse()
                      • singleton()
                      • sort()
                      • sort_by()
                      • span()
                      • tail()
                      • take()
                      • transpose()
                      • uncons()
                      • zip()
                      • zip_with()
                    • hydra.overlay.python.lib.literals module
                      • base64_to_binary()
                      • bigint_to_decimal()
                      • bigint_to_int16()
                      • bigint_to_int32()
                      • bigint_to_int64()
                      • bigint_to_int8()
                      • bigint_to_uint16()
                      • bigint_to_uint32()
                      • bigint_to_uint64()
                      • bigint_to_uint8()
                      • binary_to_base64()
                      • binary_to_bytes()
                      • decimal_to_bigint()
                      • decimal_to_float32()
                      • decimal_to_float64()
                      • float32_to_decimal()
                      • float32_to_float64()
                      • float64_to_decimal()
                      • float64_to_float32()
                      • int16_to_bigint()
                      • int32_to_bigint()
                      • int64_to_bigint()
                      • int8_to_bigint()
                      • parse_bigint()
                      • parse_boolean()
                      • parse_decimal()
                      • parse_float32()
                      • parse_float64()
                      • parse_int16()
                      • parse_int32()
                      • parse_int64()
                      • parse_int8()
                      • parse_string()
                      • parse_uint16()
                      • parse_uint32()
                      • parse_uint64()
                      • parse_uint8()
                      • print_bigint()
                      • print_boolean()
                      • print_decimal()
                      • print_float32()
                      • print_float64()
                      • print_int16()
                      • print_int32()
                      • print_int64()
                      • print_int8()
                      • print_string()
                      • print_uint16()
                      • print_uint32()
                      • print_uint64()
                      • print_uint8()
                      • uint16_to_bigint()
                      • uint32_to_bigint()
                      • uint64_to_bigint()
                      • uint8_to_bigint()
                    • hydra.overlay.python.lib.logic module
                      • and_()
                      • if_else()
                      • not_()
                      • or_()
                    • hydra.overlay.python.lib.maps module
                      • alter()
                      • bimap()
                      • delete()
                      • elems()
                      • empty()
                      • filter()
                      • filter_with_key()
                      • find_with_default()
                      • from_list()
                      • insert()
                      • is_empty()
                      • keys()
                      • lookup()
                      • map()
                      • map_keys()
                      • member()
                      • singleton()
                      • size()
                      • to_list()
                      • union()
                    • hydra.overlay.python.lib.math module
                      • abs()
                      • abs_()
                      • acos()
                      • acosh()
                      • add()
                      • add_float64()
                      • asin()
                      • asinh()
                      • atan()
                      • atan2()
                      • atanh()
                      • ceiling()
                      • cos()
                      • cosh()
                      • div()
                      • divide()
                      • e()
                      • even()
                      • exp()
                      • floor()
                      • log()
                      • log_base()
                      • max()
                      • max_()
                      • maybe_pred()
                      • maybe_succ()
                      • min()
                      • min_()
                      • mod()
                      • mul()
                      • mul_float64()
                      • negate()
                      • negate_float64()
                      • odd()
                      • pi()
                      • pow()
                      • pow_()
                      • range_()
                      • rem()
                      • round()
                      • round_()
                      • round_float32()
                      • round_float64()
                      • signum()
                      • sin()
                      • sinh()
                      • sqrt()
                      • sub()
                      • sub_float64()
                      • tan()
                      • tanh()
                      • truncate()
                    • hydra.overlay.python.lib.optionals module
                      • apply()
                      • bind()
                      • compose()
                      • given()
                      • givens()
                      • is_given()
                      • is_none()
                      • map()
                      • map_optional()
                      • match()
                      • to_list()
                      • with_default()
                    • hydra.overlay.python.lib.ordering module
                      • compare()
                      • gt()
                      • gte()
                      • lt()
                      • lte()
                      • max()
                      • min()
                    • hydra.overlay.python.lib.pairs module
                      • bimap()
                      • first()
                      • pair()
                      • second()
                    • hydra.overlay.python.lib.regex module
                      • find()
                      • find_all()
                      • matches()
                      • replace()
                      • replace_all()
                      • split()
                    • hydra.overlay.python.lib.sets module
                      • delete()
                      • difference()
                      • empty()
                      • filter()
                      • from_list()
                      • insert()
                      • intersection()
                      • is_empty()
                      • map()
                      • member()
                      • singleton()
                      • size()
                      • to_list()
                      • union()
                      • unions()
                    • hydra.overlay.python.lib.strings module
                      • char_at()
                      • concat()
                      • concat2()
                      • from_list()
                      • is_empty()
                      • join()
                      • length()
                      • split_on()
                      • to_list()
                      • to_lower()
                      • to_upper()
                      • words()
                    • hydra.overlay.python.lib.system module
                      • execute()
                      • exit()
                      • get_environment()
                      • get_environment_variable()
                      • get_time()
                      • get_working_directory()
                      • read_stdin()
                      • write_stderr()
                      • write_stdout()
                    • hydra.overlay.python.lib.text module
                      • decode_utf8()
                      • encode_utf8()
                  • Module contents
                • hydra.overlay.python.sources package
                  • Submodules
                    • hydra.overlay.python.sources.libraries module
                      • fun()
                      • register_chars_primitives()
                      • register_default_fallback_primitives()
                      • register_effects_primitives()
                      • register_eithers_primitives()
                      • register_equality_primitives()
                      • register_files_primitives()
                      • register_functions_primitives()
                      • register_hashing_primitives()
                      • register_lists_primitives()
                      • register_literals_primitives()
                      • register_logic_primitives()
                      • register_maps_primitives()
                      • register_math_primitives()
                      • register_optionals_primitives()
                      • register_ordering_primitives()
                      • register_pairs_primitives()
                      • register_regex_primitives()
                      • register_sets_primitives()
                      • register_strings_primitives()
                      • register_system_primitives()
                      • register_text_primitives()
                      • standard_library()
                      • unsupported_effect_primitive()
                  • Module contents
                • hydra.overlay.python.util package
                  • Submodules
                    • hydra.overlay.python.util.cons_list module
                      • ConsList
                        • ConsList.concat()
                        • ConsList.cons()
                        • ConsList.drop()
                        • ConsList.empty()
                        • ConsList.filter()
                        • ConsList.foldl()
                        • ConsList.foldr()
                        • ConsList.from_iterable()
                        • ConsList.head
                        • ConsList.init()
                        • ConsList.is_empty()
                        • ConsList.last()
                        • ConsList.map()
                        • ConsList.of()
                        • ConsList.reverse()
                        • ConsList.singleton()
                        • ConsList.tail
                        • ConsList.take()
                    • hydra.overlay.python.util.lazy module
                      • Lazy
                        • Lazy.get()
                    • hydra.overlay.python.util.persistent_map module
                      • PersistentMap
                        • PersistentMap.alter()
                        • PersistentMap.bimap()
                        • PersistentMap.contains_key()
                        • PersistentMap.delete()
                        • PersistentMap.empty()
                        • PersistentMap.filter()
                        • PersistentMap.filter_with_key()
                        • PersistentMap.fold()
                        • PersistentMap.from_mapping()
                        • PersistentMap.from_pairs()
                        • PersistentMap.insert()
                        • PersistentMap.is_empty()
                        • PersistentMap.items()
                        • PersistentMap.keys()
                        • PersistentMap.keys_list()
                        • PersistentMap.lookup()
                        • PersistentMap.map_keys()
                        • PersistentMap.map_values()
                        • PersistentMap.of_entries()
                        • PersistentMap.singleton()
                        • PersistentMap.to_list()
                        • PersistentMap.union()
                        • PersistentMap.values()
                        • PersistentMap.values_list()
                    • hydra.overlay.python.util.persistent_set module
                      • PersistentSet
                        • PersistentSet.delete()
                        • PersistentSet.difference()
                        • PersistentSet.empty()
                        • PersistentSet.filter()
                        • PersistentSet.from_iterable()
                        • PersistentSet.insert()
                        • PersistentSet.intersection()
                        • PersistentSet.is_empty()
                        • PersistentSet.map()
                        • PersistentSet.member()
                        • PersistentSet.of()
                        • PersistentSet.singleton()
                        • PersistentSet.to_list()
                        • PersistentSet.union()
                        • PersistentSet.unions()
                  • Module contents
                    • ConsList
                      • ConsList.concat()
                      • ConsList.cons()
                      • ConsList.drop()
                      • ConsList.empty()
                      • ConsList.filter()
                      • ConsList.foldl()
                      • ConsList.foldr()
                      • ConsList.from_iterable()
                      • ConsList.head
                      • ConsList.init()
                      • ConsList.is_empty()
                      • ConsList.last()
                      • ConsList.map()
                      • ConsList.of()
                      • ConsList.reverse()
                      • ConsList.singleton()
                      • ConsList.tail
                      • ConsList.take()
                    • Lazy
                      • Lazy.get()
                    • PersistentMap
                      • PersistentMap.alter()
                      • PersistentMap.bimap()
                      • PersistentMap.contains_key()
                      • PersistentMap.delete()
                      • PersistentMap.empty()
                      • PersistentMap.filter()
                      • PersistentMap.filter_with_key()
                      • PersistentMap.fold()
                      • PersistentMap.from_mapping()
                      • PersistentMap.from_pairs()
                      • PersistentMap.insert()
                      • PersistentMap.is_empty()
                      • PersistentMap.items()
                      • PersistentMap.keys()
                      • PersistentMap.keys_list()
                      • PersistentMap.lookup()
                      • PersistentMap.map_keys()
                      • PersistentMap.map_values()
                      • PersistentMap.of_entries()
                      • PersistentMap.singleton()
                      • PersistentMap.to_list()
                      • PersistentMap.union()
                      • PersistentMap.values()
                      • PersistentMap.values_list()
                    • PersistentSet
                      • PersistentSet.delete()
                      • PersistentSet.difference()
                      • PersistentSet.empty()
                      • PersistentSet.filter()
                      • PersistentSet.from_iterable()
                      • PersistentSet.insert()
                      • PersistentSet.intersection()
                      • PersistentSet.is_empty()
                      • PersistentSet.map()
                      • PersistentSet.member()
                      • PersistentSet.of()
                      • PersistentSet.singleton()
                      • PersistentSet.to_list()
                      • PersistentSet.union()
                      • PersistentSet.unions()
              • Submodules
                • hydra.overlay.python.tools module
                  • primitive()
              • 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.emacs.regex module
                  • alternation()
                  • atom()
                  • character_class()
                  • class_item()
                  • escape_class_char()
                  • escape_literal()
                  • print_code_point()
                  • print_regex()
                  • quantified()
                  • quantifier()
                  • regex_sequence()
            • hydra.print.error namespace
              • Submodules
                • hydra.print.error.core module
                  • constant_condition_error()
                  • duplicate_binding_error()
                  • duplicate_field_error()
                  • duplicate_record_type_field_names_error()
                  • duplicate_union_type_field_names_error()
                  • empty_case_statement_error()
                  • empty_let_bindings_error()
                  • empty_record_type_error()
                  • empty_term_annotation_error()
                  • empty_type_annotation_error()
                  • empty_type_name_in_term_error()
                  • empty_union_type_error()
                  • extra_record_fields_error()
                  • invalid_forall_parameter_name_error()
                  • invalid_lambda_parameter_name_error()
                  • invalid_let_binding_name_error()
                  • invalid_term_error()
                  • invalid_type_error()
                  • invalid_type_lambda_parameter_name_error()
                  • invalid_type_scheme_variable_name_error()
                  • missing_case_branches_error()
                  • missing_record_fields_error()
                  • nested_term_annotation_error()
                  • nested_type_annotation_error()
                  • nominal_type_kind_mismatch_error()
                  • non_comparable_map_key_type_error()
                  • non_comparable_set_element_type_error()
                  • redundant_wrap_unwrap_error()
                  • self_application_error()
                  • single_variant_union_error()
                  • term_variable_shadowing_error()
                  • type_variable_shadowing_in_forall_error()
                  • type_variable_shadowing_in_type_lambda_error()
                  • undeclared_variant_error()
                  • undefined_field_error()
                  • undefined_term_variable_error()
                  • undefined_type_variable_error()
                  • undefined_type_variable_in_binding_type_error()
                  • undefined_type_variable_in_lambda_domain_error()
                  • undefined_type_variable_in_type_application_error()
                  • unexpected_term_variant_error()
                  • unexpected_type_variant_error()
                  • unknown_case_alternative_error()
                  • unknown_primitive_name_error()
                  • unknown_projected_field_error()
                  • unnecessary_identity_application_error()
                  • unresolved_nominal_type_error()
                  • untyped_term_variable_error()
                  • void_in_non_bottom_position_error()
                • hydra.print.error.packaging module
                  • conflicting_module_name_error()
                  • conflicting_variant_name_error()
                  • definition_not_in_module_name_error()
                  • definitions_out_of_order_error()
                  • duplicate_definition_name_error()
                  • duplicate_module_name_error()
                  • invalid_definition_name_error()
                  • invalid_module_error()
                  • invalid_module_name_convention_error()
                  • invalid_package_error()
                  • invalid_package_name_error()
                  • missing_documentation_error()
                  • undeclared_dependency_error()
            • hydra.print.pcre namespace
              • Submodules
                • hydra.print.pcre.regex module
                  • alternation()
                  • atom()
                  • character_class()
                  • class_item()
                  • escape_class_char()
                  • escape_literal()
                  • print_code_point()
                  • print_regex()
                  • quantified()
                  • quantifier()
                  • regex_sequence()
            • hydra.print.posix namespace
              • Submodules
                • hydra.print.posix.regex module
                  • alternation()
                  • any_class()
                  • atom()
                  • character_class()
                  • class_item()
                  • escape_class_char()
                  • escape_literal()
                  • print_code_point()
                  • print_regex()
                  • quantified()
                  • quantifier()
                  • regex_sequence()
          • 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_
                • Node_.MAPPING
                • Node_.SCALAR
                • Node_.SEQUENCE
                • Node_.TYPE_
              • Scalar
                • Scalar.BOOL
                • Scalar.DECIMAL
                • Scalar.FLOAT
                • Scalar.INT
                • Scalar.NULL
                • Scalar.STR
                • Scalar.TYPE_
              • 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
hydra-kernel
  • hydra
  • hydra namespace
  • hydra.lib namespace
  • View page source

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
Previous Next

© Copyright 2026, Hydra.

Built with Sphinx using a theme provided by Read the Docs.