Skip to content

templates

Provide semantic-facing template metadata for compile-time specialization without requiring parser-level syntax support inside IRx.

Classes:

Functions:

TemplateParam dataclass 

TemplateParam(
    name: str,
    bound: DataType,
    loc: SourceLocation = NO_SOURCE_LOCATION,
)

Describe one bounded template variable attached to a function or method declaration. attributes: name: type: str bound: type: astx.DataType loc: type: astx.SourceLocation

TemplateTypeVar 

TemplateTypeVar(name: str, *, bound: DataType)

Bases: AnyType

Represent one unresolved template type parameter inside function signatures or local declared types before specialization. attributes: name: type: str bound: type: astx.DataType

Methods:

Source code in src/irx/astx/types.py 
 98
 99
100
101
102
103
104
105
106
107
108
109
def __init__(self, name: str, *, bound: astx.DataType) -> None:
    """
    title: Initialize one template type variable.
    parameters:
      name:
        type: str
      bound:
        type: astx.DataType
    """
    super().__init__()
    self.name = name
    self.bound = bound

get_struct 

get_struct(simplified: bool = False) -> ReprStruct
Source code in src/irx/astx/types.py 
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
def get_struct(self, simplified: bool = False) -> astx.base.ReprStruct:
    """
    title: Build one repr structure for a template type variable.
    parameters:
      simplified:
        type: bool
    returns:
      type: astx.base.ReprStruct
    """
    key = f"TEMPLATE_TYPE_VAR[{self.name}]"
    value = cast(
        astx.base.DataTypesStruct,
        {
            "name": self.name,
            "bound": self.bound.get_struct(simplified),
        },
    )
    return self._prepare_struct(key, value, simplified)

UnionType 

UnionType(
    members: Iterable[DataType],
    *,
    alias_name: str | None = None,
)

Bases: AnyType

Represent one union of concrete type references that semantic analysis may enumerate as a finite type domain. attributes: members: type: tuple[astx.DataType, Ellipsis] alias_name: type: str | None

Methods:

Source code in src/irx/astx/types.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
def __init__(
    self,
    members: Iterable[astx.DataType],
    *,
    alias_name: str | None = None,
) -> None:
    """
    title: Initialize one finite union type.
    parameters:
      members:
        type: Iterable[astx.DataType]
      alias_name:
        type: str | None
    """
    super().__init__()
    self.members = tuple(members)
    self.alias_name = alias_name

get_struct 

get_struct(simplified: bool = False) -> ReprStruct
Source code in src/irx/astx/types.py 
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
def get_struct(self, simplified: bool = False) -> astx.base.ReprStruct:
    """
    title: Build one repr structure for a finite union type.
    parameters:
      simplified:
        type: bool
    returns:
      type: astx.base.ReprStruct
    """
    key = f"UNION[{self.alias_name or id(self)}]"
    value = cast(
        astx.base.DataTypesStruct,
        [member.get_struct(simplified) for member in self.members],
    )
    return self._prepare_struct(key, value, simplified)

add_generated_template_node 

add_generated_template_node(
    module: Module, node: AST
) -> None
Source code in src/irx/astx/templates.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
@typechecked
def add_generated_template_node(
    module: astx.Module,
    node: astx.AST,
) -> None:
    """
    title: Attach one generated template node to a module.
    parameters:
      module:
        type: astx.Module
      node:
        type: astx.AST
    """
    nodes = list(getattr(module, _GENERATED_TEMPLATE_NODES_ATTR, ()))
    nodes.append(node)
    setattr(module, _GENERATED_TEMPLATE_NODES_ATTR, tuple(nodes))

clear_generated_template_nodes 

clear_generated_template_nodes(module: Module) -> None
Source code in src/irx/astx/templates.py 
185
186
187
188
189
190
191
192
193
@typechecked
def clear_generated_template_nodes(module: astx.Module) -> None:
    """
    title: Remove generated template nodes attached to one module.
    parameters:
      module:
        type: astx.Module
    """
    setattr(module, _GENERATED_TEMPLATE_NODES_ATTR, ())

generated_template_nodes 

generated_template_nodes(module: Module) -> tuple[AST, ...]
Source code in src/irx/astx/templates.py 
196
197
198
199
200
201
202
203
204
205
206
207
@typechecked
def generated_template_nodes(module: astx.Module) -> tuple[astx.AST, ...]:
    """
    title: Return the generated template nodes attached to a module.
    parameters:
      module:
        type: astx.Module
    returns:
      type: tuple[astx.AST, Ellipsis]
    """
    value = getattr(module, _GENERATED_TEMPLATE_NODES_ATTR, ())
    return tuple(value)

get_template_args 

get_template_args(node: AST) -> tuple[DataType, ...] | None
Source code in src/irx/astx/templates.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
@typechecked
def get_template_args(node: astx.AST) -> tuple[astx.DataType, ...] | None:
    """
    title: Return the explicit template arguments attached to one AST node.
    parameters:
      node:
        type: astx.AST
    returns:
      type: tuple[astx.DataType, Ellipsis] | None
    """
    value = getattr(node, _TEMPLATE_ARGS_ATTR, None)
    if value is None:
        return None
    return tuple(value)

get_template_params 

get_template_params(node: AST) -> tuple[TemplateParam, ...]
Source code in src/irx/astx/templates.py 
62
63
64
65
66
67
68
69
70
71
72
73
@typechecked
def get_template_params(node: astx.AST) -> tuple[TemplateParam, ...]:
    """
    title: Return the template parameters attached to one AST node.
    parameters:
      node:
        type: astx.AST
    returns:
      type: tuple[TemplateParam, Ellipsis]
    """
    value = getattr(node, _TEMPLATE_PARAMS_ATTR, ())
    return tuple(value)

is_template_node 

is_template_node(node: AST) -> bool
Source code in src/irx/astx/templates.py 
76
77
78
79
80
81
82
83
84
85
86
@typechecked
def is_template_node(node: astx.AST) -> bool:
    """
    title: Return whether one AST node carries template parameters.
    parameters:
      node:
        type: astx.AST
    returns:
      type: bool
    """
    return bool(get_template_params(node))

is_template_specialization 

is_template_specialization(node: AST) -> bool
Source code in src/irx/astx/templates.py 
154
155
156
157
158
159
160
161
162
163
164
@typechecked
def is_template_specialization(node: astx.AST) -> bool:
    """
    title: Return whether one AST node is a generated specialization.
    parameters:
      node:
        type: astx.AST
    returns:
      type: bool
    """
    return template_specialization_name(node) is not None

mark_template_specialization 

mark_template_specialization(
    node: AST, specialization_name: str
) -> None
Source code in src/irx/astx/templates.py 
124
125
126
127
128
129
130
131
132
133
134
135
136
137
@typechecked
def mark_template_specialization(
    node: astx.AST,
    specialization_name: str,
) -> None:
    """
    title: Mark one AST node as a generated template specialization.
    parameters:
      node:
        type: astx.AST
      specialization_name:
        type: str
    """
    setattr(node, _TEMPLATE_SPECIALIZATION_ATTR, specialization_name)

set_template_args 

set_template_args(
    node: AST, args: Iterable[DataType] | None
) -> None
Source code in src/irx/astx/templates.py 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
@typechecked
def set_template_args(
    node: astx.AST,
    args: Iterable[astx.DataType] | None,
) -> None:
    """
    title: Attach explicit template arguments to one call-like AST node.
    parameters:
      node:
        type: astx.AST
      args:
        type: Iterable[astx.DataType] | None
    """
    if args is None:
        setattr(node, _TEMPLATE_ARGS_ATTR, None)
        return
    setattr(node, _TEMPLATE_ARGS_ATTR, tuple(args))

set_template_params 

set_template_params(
    node: AST, params: Iterable[TemplateParam]
) -> None
Source code in src/irx/astx/templates.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
@typechecked
def set_template_params(
    node: astx.AST,
    params: Iterable[TemplateParam],
) -> None:
    """
    title: Attach template parameters to one AST node.
    parameters:
      node:
        type: astx.AST
      params:
        type: Iterable[TemplateParam]
    """
    setattr(node, _TEMPLATE_PARAMS_ATTR, tuple(params))

template_specialization_name 

template_specialization_name(node: AST) -> str | None
Source code in src/irx/astx/templates.py 
140
141
142
143
144
145
146
147
148
149
150
151
@typechecked
def template_specialization_name(node: astx.AST) -> str | None:
    """
    title: Return the generated specialization name for one AST node.
    parameters:
      node:
        type: astx.AST
    returns:
      type: str | None
    """
    value = getattr(node, _TEMPLATE_SPECIALIZATION_ATTR, None)
    return value if isinstance(value, str) else None