hydra.haskell.utils module

Utilities for working with Haskell syntax trees.

hydra.haskell.utils.application_pattern(name: Name, args: Sequence[Pattern]) → Pattern

Create an application pattern from a name and argument patterns.

hydra.haskell.utils.element_reference(namespaces: ModuleNames[ModuleName], name: Name) → Name

Generate a Haskell name reference for a Hydra element.

hydra.haskell.utils.hsapp(l: Expression, r: Expression) → Expression

Create a Haskell function application expression.

hydra.haskell.utils.hslambda(name: Name, rhs: Expression) → Expression

Create a Haskell lambda expression.

hydra.haskell.utils.hslit(lit: Literal) → Expression

Create a Haskell literal expression.

hydra.haskell.utils.hsvar(s: str) → Expression

Create a Haskell variable expression from a string.

hydra.haskell.utils.namespaces_for_module(mod: Module, cx: T0, g: Graph) → object

Compute the Haskell module namespaces for a Hydra module.

hydra.haskell.utils.newtype_accessor_name(name: Name) → str

Generate an accessor name for a newtype wrapper (e.g., ‘unFoo’ for Foo).

hydra.haskell.utils.raw_name(n: str) → Name

Create a raw Haskell name from a string without sanitization.

hydra.haskell.utils.record_field_reference(namespaces: ModuleNames[ModuleName], sname: Name, fname: Name) → Name

Generate a Haskell name for a record field accessor.

hydra.haskell.utils.sanitize_haskell_name(v1: str) → str

Sanitize a string to be a valid Haskell identifier, escaping reserved words.

hydra.haskell.utils.simple_name(arg_: str) → Name

Create a sanitized Haskell name from a string.

hydra.haskell.utils.simple_value_binding(hname: Name, rhs: Expression, bindings: object) → ValueBinding

Create a simple value binding (e.g., ‘foo = expr’ or ‘foo = expr where …’).

hydra.haskell.utils.to_type_application(types: Sequence[Type]) → Type

Convert a list of types into a nested type application.

hydra.haskell.utils.type_name_for_record(sname: Name) → str

Extract the local type name from a fully qualified record type name.

hydra.haskell.utils.union_field_reference(bound_names: Set[Name], namespaces: ModuleNames[ModuleName], sname: Name, fname: Name) → Name

Generate a Haskell name for a union variant constructor, with disambiguation.

hydra.haskell.utils.unpack_forall_type(t: Type) → tuple[Sequence[Name], Type]

Unpack nested forall types into a list of type variables and the inner type.