hydra.java.coder module

Java code generator: converts Hydra modules to Java source code.

hydra.java.coder.add_comment(decl: ClassBodyDeclaration, field: FieldType, cx: T0, g: Graph) → object

Attach comments derived from a field’s annotations to a class body declaration.

hydra.java.coder.analyze_java_function(env: JavaEnvironment, term: Term, cx: InferenceContext, g: T0) → object

hydra.java.coder.annotate_body_with_cod(typ: Type, term: Term) → Term

hydra.java.coder.annotate_lambda_args(cname: Name, t_apps: Sequence[Type], arg_terms: Sequence[Term], cx: T0, g: Graph) → object

hydra.java.coder.apply_cast_if_safe(aliases: Aliases, cast_type: Type, expr: Expression, cx: T0, g: Graph) → object

hydra.java.coder.apply_java_arg(expr: Expression, jarg: Expression) → Expression

hydra.java.coder.apply_overgen_subst_to_term_annotations(subst: Mapping[Name, Type], term0: Term, cx: T0, g: Graph) → object

hydra.java.coder.apply_overgen_subst_to_term_annotations_go(subst: Mapping[Name, Type], cx: Graph, term: Term) → Term

hydra.java.coder.apply_subst_full(s: Mapping[Name, Type], t: Type) → Type

hydra.java.coder.apply_subst_simple(subst: Mapping[Name, Type], t: Type) → Type

hydra.java.coder.arrays_compare_expr(other_var: str, fname: str) → Expression

hydra.java.coder.arrays_equals_clause(tmp_name: str, fname: str) → InclusiveOrExpression

hydra.java.coder.augment_variant_class(aliases: Aliases, tparams: Sequence[TypeParameter], el_name: Name, cd: ClassDeclaration) → ClassDeclaration

hydra.java.coder.binding_is_function_type(b: Binding) → bool

hydra.java.coder.binding_name_to_file_path(name: Name) → str

hydra.java.coder.bindings_to_statements(env: JavaEnvironment, bindings: Sequence[Binding], cx: InferenceContext, g0: Graph) → object

hydra.java.coder.bound_type_variables(typ: Type) → Sequence[Name]

hydra.java.coder.build_arg_subst(scheme_var_set: Set[Name], scheme_doms: Sequence[Type], arg_types: Sequence[T0]) → Mapping[Name, T0]

hydra.java.coder.build_curried_lambda(params: Sequence[Name], inner: Expression) → Expression

hydra.java.coder.build_subst_from_annotations(scheme_var_set: Set[Name], term: Term, cx: T0, g: Graph) → object

hydra.java.coder.build_subst_from_annotations_go(scheme_var_set: Set[Name], g: Graph, term: Term) → Mapping[Name, Name]

hydra.java.coder.build_type_subst(scheme_var_set: Set[Name], scheme_type: Type, actual_type: Type) → Mapping[Name, Type]

hydra.java.coder.build_type_subst_go(svs: Set[Name], st: Type, at: Type) → Mapping[Name, Type]

hydra.java.coder.build_type_var_subst(scheme_var_set: Set[Name], fresh_typ: Type, canon_typ: Type) → Mapping[Name, Name]

hydra.java.coder.build_type_var_subst_go(svs: Set[Name], ft: Type, ct: Type) → Mapping[Name, Name]

hydra.java.coder.builder_setter_name(fname: Name) → str

hydra.java.coder.classify_data_reference(name: Name, cx: T0, g: Graph) → object

hydra.java.coder.classify_data_term(ts: TypeScheme, term: Term) → JavaSymbolClass

hydra.java.coder.classify_data_term_count_lambda_params(t: Term) → int

hydra.java.coder.classify_data_term_strip_type_lambdas(t: Term) → Term

hydra.java.coder.cmp_decl_statement(aliases: T0) → BlockStatement

hydra.java.coder.cmp_not_zero_expr() → Expression

hydra.java.coder.collect_forall_params(t: Type) → Sequence[Name]

hydra.java.coder.collect_lambda_domains(t: Term) → tuple[Sequence[Type], Term]

hydra.java.coder.collect_type_apps(t: Term, acc: Sequence[Type]) → tuple[Term, Sequence[Type]]

hydra.java.coder.collect_type_apps0(t: Term, acc: Sequence[Type]) → tuple[Term, Sequence[Type]]

hydra.java.coder.collect_type_vars(typ: Type) → Set[Name]

hydra.java.coder.collect_type_vars_go(t: Type) → Set[Name]

hydra.java.coder.collection_type_args(label: str, n: int, aliases: Aliases, anns: Sequence[Mapping[Name, Term]], tyapps: Sequence[Type], cx: T0, g: Graph) → object

hydra.java.coder.comparable_compare_expr(other_var: str, fname: str) → Expression

hydra.java.coder.compare_and_return_stmts(other_var: str, f: FieldType) → Sequence[BlockStatement]

hydra.java.coder.compare_field_expr(other_var: str, ft: FieldType) → Expression

hydra.java.coder.compare_to_body(aliases: T0, other_var: str, fields: Sequence[FieldType]) → Sequence[BlockStatement]

hydra.java.coder.compare_to_zero_clause(tmp_name: str, fname: str) → InclusiveOrExpression

hydra.java.coder.constant_decl(comment: str, java_name: str, aliases: Aliases, name: Name, cx: InferenceContext, g: Graph) → object

hydra.java.coder.constant_decl_for_field_type(parent_name: Name, aliases: Aliases, ftyp: FieldType, cx: InferenceContext, g: Graph) → object

hydra.java.coder.constant_decl_for_type_name(aliases: Aliases, name: Name, cx: InferenceContext, g: Graph) → object

hydra.java.coder.construct_elements_interface(mod: Module, members: Sequence[InterfaceMemberDeclarationWithComments]) → tuple[Name, CompilationUnit]

hydra.java.coder.correct_cast_type(inner_body: Term, type_args: Sequence[Type], fallback: Type, cx: T0, g: T1) → object

hydra.java.coder.correct_type_apps(gr: T0, name: Name, args: Sequence[Term], fallback_type_apps: Sequence[Type], cx: T1, g: Graph) → object

hydra.java.coder.correct_type_apps_with_args(scheme_vars: Sequence[Name], fallback_type_apps: Sequence[Type], scheme_type: Type, args: Sequence[Term], cx: T0, g: Graph) → object

hydra.java.coder.count_function_params(t: Type) → int

hydra.java.coder.declaration_for_record_type(is_inner: bool, is_ser: bool, aliases: Aliases, tparams: Sequence[TypeParameter], el_name: Name, fields: Sequence[FieldType], cx: InferenceContext, g: Graph) → object

hydra.java.coder.declaration_for_record_type_(is_inner: bool, is_ser: bool, aliases: Aliases, tparams: Sequence[TypeParameter], el_name: Name, parent_name: object, ordinal: object, fields: Sequence[FieldType], cx: InferenceContext, g: Graph) → object

hydra.java.coder.declaration_for_union_type(is_ser: bool, aliases: Aliases, tparams: Sequence[TypeParameter], el_name: Name, fields: Sequence[FieldType], cx: InferenceContext, g: Graph) → object

hydra.java.coder.decode_type_from_term(term: Term) → object

hydra.java.coder.dedup_bindings(in_scope: Set[Name], bs: Sequence[Binding]) → Sequence[Binding]

hydra.java.coder.detect_accumulator_unification(doms: Sequence[Type], cod: Type, tparams: Sequence[Name]) → Mapping[Name, Type]

hydra.java.coder.direct_ref_substitution(direct_input_vars: Set[T0], cod_var: object, grouped: Mapping[T0, Sequence[T0]]) → Mapping[T0, T0]

hydra.java.coder.direct_ref_substitution_process_group(direct_input_vars: Set[T0], cod_var: object, subst: Mapping[T0, T0], in_var: T0, out_vars: Sequence[T0]) → Mapping[T0, T0]

hydra.java.coder.dom_type_args(aliases: Aliases, d: Type, cx: T0, g: Graph) → object

hydra.java.coder.element_java_identifier(is_prim: bool, is_method: bool, aliases: Aliases, name: Name) → Identifier

hydra.java.coder.element_java_identifier_qualify(aliases: Aliases, mns: object, s: str) → str

hydra.java.coder.elements_class_name(ns: ModuleName) → str

hydra.java.coder.elements_qualified_name(ns: ModuleName) → Name

hydra.java.coder.encode_application(env: JavaEnvironment, app: Application, cx: InferenceContext, g0: Graph) → object

hydra.java.coder.encode_application_fallback(env: JavaEnvironment, aliases: Aliases, gr: Graph, type_apps: Sequence[Type], lhs: Term, rhs: Term, cx: InferenceContext, g: Graph) → object

hydra.java.coder.encode_definitions(overlay_subs: Set[str], mod: Module, defs: Sequence[Definition], cx: InferenceContext, g: Graph) → object

hydra.java.coder.encode_elimination(env: JavaEnvironment, marg: object, dom: Type, cod: Type, elim_term: Term, cx: InferenceContext, g: Graph) → object

hydra.java.coder.encode_function(env: JavaEnvironment, dom: Type, cod: Type, fun_term: Term, cx: InferenceContext, g: Graph) → object

hydra.java.coder.encode_function_form_term(env: JavaEnvironment, anns: Sequence[Mapping[Name, Term]], term: Term, cx: InferenceContext, g: Graph) → object

hydra.java.coder.encode_function_primitive_by_name(env: JavaEnvironment, dom: Type, cod: Type, name: Name, cx: T0, g: Graph) → object

hydra.java.coder.encode_literal(lit: Literal) → Expression

hydra.java.coder.encode_literal_encode_float(f: FloatValue) → Expression

hydra.java.coder.encode_literal_encode_float32(v: float) → Expression

hydra.java.coder.encode_literal_encode_float64(v: float) → Expression

hydra.java.coder.encode_literal_encode_integer(i: IntegerValue) → Expression

hydra.java.coder.encode_literal_java_parse_double(value: str) → Expression

hydra.java.coder.encode_literal_java_special_float_expr(class_name: str, field_name: str) → Expression

hydra.java.coder.encode_literal_lit_exp(l: Literal) → Expression

hydra.java.coder.encode_literal_prim_cast(pt: PrimitiveType, expr: Expression) → Expression

hydra.java.coder.encode_literal_type(lt: LiteralType, cx: T0, g: T1) → object

hydra.java.coder.encode_literal_type_simple(n: str, cx: T0, g: T1) → object

hydra.java.coder.encode_nullary_constant(env: T0, typ: T1, fun_term: Term, cx: T2, g: T3) → object

hydra.java.coder.encode_nullary_constant_type_args_from_return_type(aliases: Aliases, t: Type, cx: T0, g: Graph) → object

hydra.java.coder.encode_nullary_primitive_by_name(env: JavaEnvironment, typ: Type, name: Name, cx: T0, g: Graph) → object

hydra.java.coder.encode_term(env: JavaEnvironment, term: Term, cx: InferenceContext, g: Graph) → object

hydra.java.coder.encode_term_definition(env: JavaEnvironment, tdef: TermDefinition, cx: InferenceContext, g: Graph) → object

hydra.java.coder.encode_term_internal(env: JavaEnvironment, anns: Sequence[Mapping[Name, Term]], tyapps: Sequence[Type], term: Term, cx: InferenceContext, g0: Graph) → object

hydra.java.coder.encode_term_t_c_o(env0: JavaEnvironment, func_name: Name, param_names: Sequence[Name], tparams: Sequence[Name], tco_var_renames: Mapping[Name, Name], tco_depth: int, term: Term, cx: InferenceContext, g: Graph) → object

hydra.java.coder.encode_type(aliases: Aliases, bound_vars: Set[Name], t: Type, cx: T0, g: Graph) → object

hydra.java.coder.encode_type_definition(pkg: PackageDeclaration, aliases: Aliases, tdef: TypeDefinition, cx: InferenceContext, g: Graph) → object

hydra.java.coder.encode_type_resolve_if_typedef(aliases: T0, bound_vars: Set[Name], in_scope_type_params: Set[Name], name: Name, cx: T1, g: Graph) → object

hydra.java.coder.encode_variable(env: JavaEnvironment, name: Name, cx: T0, g: Graph) → object

hydra.java.coder.encode_variable_build_curried(params: Sequence[Name], inner: Expression) → Expression

hydra.java.coder.encode_variable_hoisted_lambda_case(aliases: Aliases, name: Name, arity: int, cx: T0, g: Graph) → object

hydra.java.coder.eq_clause(tmp_name: str, ft: FieldType) → InclusiveOrExpression

hydra.java.coder.equals_clause(tmp_name: str, fname: str) → InclusiveOrExpression

hydra.java.coder.extract_arg_type(_lhs: T0, typ: Type) → Type

hydra.java.coder.extract_direct_return(tparam_set: Set[Name], t: Type) → Sequence[tuple[Name, Name]]

hydra.java.coder.extract_direct_return_go(tparam_set: Set[Name], t: Type) → Sequence[tuple[Name, Name]]

hydra.java.coder.extract_in_out_pair(t: Type) → Sequence[tuple[Name, Name]]

hydra.java.coder.extract_type_application_args(typ: Type) → Sequence[Type]

hydra.java.coder.extract_type_application_args_go(t: Type) → Sequence[Type]

hydra.java.coder.field_to_string_part(f: FieldType) → Sequence[MultiplicativeExpression]

hydra.java.coder.field_type_to_formal_param(aliases: Aliases, ft: FieldType, cx: T0, g: Graph) → object

hydra.java.coder.filter_by_flags(xs: Sequence[T0], flags: Sequence[bool]) → Sequence[T0]

hydra.java.coder.filter_phantom_type_args(callee_name: Name, all_type_args: Sequence[Type], cx: T0, g: Graph) → object

hydra.java.coder.filter_phantom_type_args_filter_and_apply(all_type_args: Sequence[Type], keep_flags: Sequence[bool], overgen_subst: Mapping[Name, Type]) → Sequence[Type]

hydra.java.coder.find_matching_lambda_var(name: Name, lambda_vars: Set[Name]) → Name

hydra.java.coder.find_pair_first(t: Type) → object

hydra.java.coder.find_self_ref_var(grouped: Mapping[T0, Sequence[T0]]) → object

hydra.java.coder.flatten_apps(t: Term, acc: Sequence[Term]) → tuple[Sequence[Term], Term]

hydra.java.coder.flatten_bindings(bindings: Sequence[Binding]) → Sequence[Binding]

hydra.java.coder.fresh_java_name(base: Name, avoid: Set[Name]) → Name

hydra.java.coder.fresh_java_name_go(base: Name, avoid: Set[Name], i: int) → Name

hydra.java.coder.function_call(env: JavaEnvironment, is_prim: bool, name: Name, args: Sequence[Term], type_apps: Sequence[Type], cx: InferenceContext, g: Graph) → object

hydra.java.coder.get_codomain(ann: Mapping[Name, Term], cx: T0, g: Graph) → object

hydra.java.coder.get_function_type(ann: Mapping[Name, Term], cx: T0, g: Graph) → object

hydra.java.coder.group_pairs_by_first(pairs: Sequence[tuple[T0, T1]]) → Mapping[T0, Sequence[T1]]

hydra.java.coder.hash_code_compare_expr(other_var: str, fname: str) → Expression

hydra.java.coder.hash_code_mult_pair(i: int, fname: Name) → MultiplicativeExpression

hydra.java.coder.hydra_ordinal_method(ordinal: object) → ClassBodyDeclaration

hydra.java.coder.inner_class_ref(aliases: Aliases, name: Name, local: str) → Identifier

hydra.java.coder.insert_branch_var(name: Name, env: JavaEnvironment) → JavaEnvironment

hydra.java.coder.interface_types(is_ser: bool, aliases: Aliases, tparams: Sequence[TypeParameter], el_name: Name) → Sequence[InterfaceType]

hydra.java.coder.is_big_numeric_type(typ: Type) → bool

hydra.java.coder.is_binary_type(typ: Type) → bool

hydra.java.coder.is_field_unit_type(type_name: Name, field_name: Name, cx: T0, g: Graph) → object

hydra.java.coder.is_lambda_bound_in(name: Name, lambda_vars: Set[Name]) → bool

hydra.java.coder.is_lambda_bound_in_is_qualified(n: Name) → bool

hydra.java.coder.is_lambda_bound_variable(name: Name) → bool

hydra.java.coder.is_local_variable(name: Name) → bool

hydra.java.coder.is_non_comparable_type(typ: Type) → bool

hydra.java.coder.is_recursive_variable(aliases: Aliases, name: Name) → bool

hydra.java.coder.is_serializable_java_type(typ: Type) → bool

hydra.java.coder.is_simple_name(name: Name) → bool

hydra.java.coder.is_unresolved_inference_var(name: Name) → bool

hydra.java.coder.is_unresolved_inference_var_is_digit(c: int) → bool

hydra.java.coder.java_comparable_ref_type() → ReferenceType

hydra.java.coder.java_env_get_graph(env: JavaEnvironment) → Graph

hydra.java.coder.java_env_set_graph(g: Graph, env: JavaEnvironment) → JavaEnvironment

hydra.java.coder.java_identifier_to_string(id: Identifier) → str

hydra.java.coder.java_type_arguments_for_named_type(tname: Name, cx: T0, g: Graph) → object

hydra.java.coder.java_type_arguments_for_type(typ: Type) → Sequence[TypeArgument]

hydra.java.coder.java_type_parameters_for_type(typ: Type) → Sequence[TypeParameter]

hydra.java.coder.java_type_parameters_for_type_bvars(t: Type) → Sequence[Name]

hydra.java.coder.lazy_flags_for_primitive(g: Graph, name: Name) → Sequence[bool]

hydra.java.coder.module_to_java(overlay_subs: Set[str], mod: Module, defs: Sequence[Definition], cx: InferenceContext, g: Graph) → object

hydra.java.coder.name_map_to_type_map(m: Mapping[T0, Name]) → Mapping[T0, Type]

hydra.java.coder.namespace_parent(ns: ModuleName) → object

hydra.java.coder.no_comment(decl: ClassBodyDeclaration) → ClassBodyDeclarationWithComments

hydra.java.coder.no_interface_comment(decl: InterfaceMemberDeclaration) → InterfaceMemberDeclarationWithComments

hydra.java.coder.otherwise_branch(env: JavaEnvironment, aliases: Aliases, dom: Type, cod: Type, tname: Name, jcod: Type, targs: Sequence[TypeArgument], d: Term, cx: InferenceContext, g: Graph) → object

hydra.java.coder.peel_domain_types(n: int, t: Type) → tuple[Sequence[Type], Type]

hydra.java.coder.peel_domains_and_cod(n: int, t: Type) → tuple[Sequence[Type], Type]

hydra.java.coder.peel_expected_types(subst: Mapping[Name, Type], n: int, t: Type) → Sequence[Type]

hydra.java.coder.propagate_type(typ: Type, term: Term) → Term

hydra.java.coder.propagate_type_propagate_into_lambda(cod: Type, t: Term) → Term

hydra.java.coder.propagate_type_rebuild_let(t: Term, bindings: Sequence[Binding], new_body: Term) → Term

hydra.java.coder.propagate_types_in_app_chain(fixed_cod: Type, result_type: Type, t: Term) → Term

hydra.java.coder.rebuild_apps(f: Term, args: Sequence[Term], f_type: Type) → Term

hydra.java.coder.record_builder_class(aliases: Aliases, tparams: Sequence[TypeParameter], el_name: Name, fields: Sequence[FieldType], cx: T0, g: Graph) → object

hydra.java.coder.record_compare_to_method(aliases: Aliases, tparams: T0, el_name: Name, fields: Sequence[FieldType]) → ClassBodyDeclaration

hydra.java.coder.record_constructor(aliases: Aliases, el_name: Name, fields: Sequence[FieldType], cx: T0, g: Graph) → object

hydra.java.coder.record_equals_method(aliases: Aliases, el_name: Name, fields: Sequence[FieldType]) → ClassBodyDeclaration

hydra.java.coder.record_hash_code_method(fields: Sequence[FieldType]) → ClassBodyDeclaration

hydra.java.coder.record_member_var(aliases: Aliases, ft: FieldType, cx: T0, g: Graph) → object

hydra.java.coder.record_to_string_method(el_name: Name, fields: Sequence[FieldType]) → ClassBodyDeclaration

hydra.java.coder.record_with_method(aliases: Aliases, el_name: Name, fields: Sequence[FieldType], field: FieldType, cx: T0, g: Graph) → object

hydra.java.coder.resolve_type_apps(scheme_vars: Sequence[Name], fallback_type_apps: Sequence[Type], arg_subst: Mapping[Name, Type]) → Sequence[Type]

hydra.java.coder.self_ref_substitution(grouped: Mapping[T0, Sequence[T0]]) → Mapping[T0, T0]

hydra.java.coder.self_ref_substitution_process_group(subst: Mapping[T0, T0], in_var: T0, out_vars: Sequence[T0]) → Mapping[T0, T0]

hydra.java.coder.serializable_types(is_ser: bool) → Sequence[InterfaceType]

hydra.java.coder.split_constant_initializer(member: InterfaceMemberDeclaration) → Sequence[InterfaceMemberDeclaration]

hydra.java.coder.split_constant_initializer_split_var(mods: Sequence[ConstantModifier], utype: UnannType, vd: VariableDeclarator) → Sequence[InterfaceMemberDeclaration]

hydra.java.coder.strip_foralls(t: Type) → Type

hydra.java.coder.substitute_type_vars_with_types(subst: Mapping[Name, Type], t: Type) → Type

hydra.java.coder.substitute_type_vars_with_types_go(subst: Mapping[Name, Type], t: Type) → Type

hydra.java.coder.tag_cmp_not_zero_expr() → Expression

hydra.java.coder.tag_compare_expr() → Expression

hydra.java.coder.take_type_args(label: str, n: int, tyapps: Sequence[Type], cx: T0, g: T1) → object

hydra.java.coder.to_class_decl(is_inner: bool, is_ser: bool, aliases: Aliases, tparams: Sequence[TypeParameter], el_name: Name, t: Type, cx: InferenceContext, g: Graph) → object

hydra.java.coder.to_decl_init(aliases_ext: Aliases, g_ext: Graph, recursive_vars: Set[Name], flat_bindings: Sequence[Binding], name: Name, cx: InferenceContext, g: Graph) → object

hydra.java.coder.to_decl_statement(env_ext: JavaEnvironment, aliases_ext: Aliases, g_ext: Graph, recursive_vars: Set[Name], thunked_vars: Set[Name], flat_bindings: Sequence[Binding], name: Name, cx: InferenceContext, g: Graph) → object

hydra.java.coder.try_infer_function_type(fun_term: Term) → object

hydra.java.coder.type_app_fallback_cast(env: JavaEnvironment, aliases: Aliases, anns: Sequence[Mapping[Name, Term]], tyapps: Sequence[Type], jatyp: Type, body: Term, typ: Type, cx: InferenceContext, g: Graph) → object

hydra.java.coder.type_app_nullary_or_hoisted(env: JavaEnvironment, aliases: Aliases, anns: Sequence[Mapping[Name, Term]], tyapps: Sequence[Type], jatyp: Type, body: Term, corrected_typ: Type, var_name: Name, cls: JavaSymbolClass, all_type_args: Sequence[Type], cx: InferenceContext, g: Graph) → object

hydra.java.coder.type_args_or_diamond(args: Sequence[TypeArgument]) → TypeArgumentsOrDiamond

hydra.java.coder.types_match(a: Type, b: Type) → bool

hydra.java.coder.unwrap_return_type(t: Type) → Type

hydra.java.coder.variant_compare_to_method(aliases: Aliases, tparams: T0, parent_name: Name, variant_name: Name, ordinal: int, fields: Sequence[FieldType]) → Sequence[ClassBodyDeclaration]

hydra.java.coder.visit_branch(env: JavaEnvironment, aliases: Aliases, dom: Type, tname: Name, jcod: Type, targs: Sequence[TypeArgument], field: CaseAlternative, cx: InferenceContext, g: Graph) → object

hydra.java.coder.with_comment_string(comment: str, decl: ClassBodyDeclaration) → ClassBodyDeclarationWithComments

hydra.java.coder.with_interface_comment_string(comment: str, decl: InterfaceMemberDeclaration) → InterfaceMemberDeclarationWithComments

hydra.java.coder.with_lambda(env: JavaEnvironment, lam: Lambda, k: Callable[[JavaEnvironment], T0]) → T0

hydra.java.coder.with_type_lambda(v1: JavaEnvironment, v2: TypeLambda, v3: Callable[[JavaEnvironment], T0]) → T0

hydra.java.coder.wrap_in_supplier_lambda(expr: Expression) → Expression

hydra.java.coder.wrap_lazy_arguments(g: Graph, name: Name, args: Sequence[Expression]) → tuple[Sequence[Expression], object]