nodes

Access dataclass

Bases: NotationTree, NotationExpression

Notation AST expression representing the value of tensor tns at the indices idx....

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Access(NotationTree, NotationExpression):
    """
    Notation AST expression representing the value of tensor `tns` at the indices
    `idx...`.
    """

    tns: NotationExpression
    mode: AccessMode
    idxs: tuple[NotationExpression, ...]

    @property
    def result_type(self):
        if len(self.idxs) == 0:
            return self.tns.result_type
        return AccessFType(self.tns.result_type)

    @classmethod
    def from_children(cls, tns, mode, *idxs):
        return cls(tns, mode, idxs)

    @property
    def children(self):
        return [self.tns, self.mode, *self.idxs]

AccessFType

Bases: FType

Source code in src/finch/finch_notation/nodes.py

class AccessFType(FType):
    obj: Any

    def __init__(self, obj: Any):
        self.obj = obj

    def __eq__(self, other):
        if not isinstance(other, AccessFType):
            return False
        return self.obj == other.obj

    def __hash__(self):
        return hash(self.obj)

    @property
    def element_type(self):
        """
        Returns the element type of the access ftype.
        """
        return self.obj.element_type

    def __call__(self, val: Any) -> Any:
        """
        Convert `val` the way the accessed tensor's type would.
        """
        return self.obj(val)

element_type property

Returns the element type of the access ftype.

__call__(val)

Convert val the way the accessed tensor's type would.

Source code in src/finch/finch_notation/nodes.py

def __call__(self, val: Any) -> Any:
    """
    Convert `val` the way the accessed tensor's type would.
    """
    return self.obj(val)

AccessMode dataclass

Bases: NotationNode

Notation AST node representing the access mode of a tensor.

Source code in src/finch/finch_notation/nodes.py

class AccessMode(NotationNode):
    """
    Notation AST node representing the access mode of a tensor.
    """

Assign dataclass

Bases: NotationTree, NotationStatement

Notation AST statement that defines lhs as having the value rhs.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Assign(NotationTree, NotationStatement):
    """
    Notation AST statement that defines `lhs` as having the value `rhs`.
    """

    lhs: Variable
    rhs: NotationExpression

    @property
    def children(self):
        return [self.lhs, self.rhs]

Block dataclass

Bases: NotationTree, NotationStatement

Notation AST statement that executes each of its arguments in turn.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Block(NotationTree, NotationStatement):
    """
    Notation AST statement that executes each of its arguments in turn.
    """

    bodies: tuple[NotationStatement, ...]

    @classmethod
    def from_children(cls, *bodies):
        return cls(bodies)

    @property
    def children(self):
        return list(self.bodies)

Cached dataclass

Bases: NotationTree, NotationExpression

Notation AST expression arg, equivalent to the quoted expression ref.

Often used after the compiler caches the computation ref into a variable arg, but we still wish to refer to the original expression to prove properties about it.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Cached(NotationTree, NotationExpression):
    """
    Notation AST expression `arg`, equivalent to the quoted expression `ref`.

    Often used after the compiler caches the computation `ref` into a variable
    `arg`, but we still wish to refer to the original expression to prove
    properties about it.
    """

    arg: NotationExpression
    ref: NotationExpression

    @property
    def result_type(self):
        return self.arg.result_type

    @property
    def children(self):
        return [self.arg, self.ref]

Call dataclass

Bases: NotationTree, NotationExpression, CallTerm

Notation AST expression for the result of calling the function op on args....

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Call(NotationTree, NotationExpression, CallTerm):
    """
    Notation AST expression for the result of calling the function `op` on
    `args...`.
    """

    op: NotationExpression
    args: tuple[NotationExpression, ...]

    @property
    def result_type(self) -> FType:
        arg_types = [a.result_type for a in self.args]
        op_type = self.op.result_type
        assert isinstance(op_type, CallableFType)
        return return_type(op_type, *arg_types)

    @classmethod
    def from_children(cls, op, *args):
        return cls(op, args)

    @property
    def children(self):
        return [self.op, *self.args]

Child dataclass

Bases: NotationTree, Cursor

A sublevel of a level expression.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Child(NotationTree, Cursor):
    """A sublevel of a level expression."""

    parent: Cursor
    attr: str = "lvl"

    @property
    def root(self):
        return self.parent.root

    @property
    def result_type(self):
        return self.parent.result_type.level_get_child_type(self.attr)

    @property
    def children(self):
        return [self.parent, Literal(self.attr)]

    @classmethod
    def from_children(cls, parent, attr):
        return cls(parent, attr.val)

Cursor dataclass

Bases: NotationExpression, ABC

A level expression that retains its owning tensor.

Source code in src/finch/finch_notation/nodes.py

class Cursor(NotationExpression, ABC):
    """A level expression that retains its owning tensor."""

    @property
    @abstractmethod
    def root(self) -> NotationExpression: ...

    @property
    @abstractmethod
    def result_type(self) -> LevelFType: ...

Declare dataclass

Bases: NotationTree, NotationStatement

Notation AST statement that declares tns with an initial value init reduced with op in the current scope. A tensor with a dynamic fill takes init as its fill.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Declare(NotationTree, NotationStatement):
    """
    Notation AST statement that declares `tns` with an initial value `init` reduced
    with `op` in the current scope. A tensor with a dynamic fill takes `init` as
    its fill.
    """

    tns: NotationExpression
    init: NotationExpression
    op: NotationExpression
    shape: tuple[NotationExpression, ...]

    @property
    def children(self):
        return [self.tns, self.init, self.op, *self.shape]

    @classmethod
    def from_children(cls, tns, init, op, *shape):
        """
        Creates a Declare node from its children.
        """
        return cls(tns, init, op, shape)

from_children(tns, init, op, *shape) classmethod

Creates a Declare node from its children.

Source code in src/finch/finch_notation/nodes.py

@classmethod
def from_children(cls, tns, init, op, *shape):
    """
    Creates a Declare node from its children.
    """
    return cls(tns, init, op, shape)

Dimension dataclass

Bases: NotationTree, NotationExpression

Notation AST expression representing the dimension of tensor tns in rank r.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Dimension(NotationTree, NotationExpression):
    """
    Notation AST expression representing the dimension of tensor `tns` in
    rank `r`.
    """

    tns: NotationExpression
    r: Literal

    @property
    def result_type(self):
        assert isinstance(self.tns.result_type, TensorFType)
        return self.tns.result_type.shape_type[self.r.val]

    @classmethod
    def from_children(cls, tns, r):
        return cls(tns, r)

    @property
    def children(self):
        return [self.tns, self.r]

Fiber dataclass

Bases: NotationTree, NotationExpression

A positioned level view, retaining the owning tensor type at the root.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Fiber(NotationTree, NotationExpression):
    """A positioned level view, retaining the owning tensor type at the root."""

    lvl: Cursor
    pos: NotationExpression
    idxs: tuple[NotationExpression, ...] = ()

    @property
    def result_type(self):
        match self.lvl:
            case Root(tns):
                return tns.result_type
        root_type = self.lvl.root.result_type
        assert isinstance(root_type, TensorFType)
        return tensor.FiberTensorFType(self.lvl.result_type, root_type.device)

    @property
    def children(self):
        return [self.lvl, self.pos, *self.idxs]

    @classmethod
    def from_children(cls, lvl, pos, *idxs):
        return cls(lvl, pos, idxs)

FillValue dataclass

Bases: NotationTree, NotationExpression

Notation AST expression representing the fill value of tensor tns.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class FillValue(NotationTree, NotationExpression):
    """
    Notation AST expression representing the fill value of tensor `tns`.
    """

    tns: NotationExpression

    @property
    def result_type(self):
        assert isinstance(self.tns.result_type, TensorFType)
        return self.tns.result_type.element_type

    @classmethod
    def from_children(cls, tns):
        return cls(tns)

    @property
    def children(self):
        return [self.tns]

Freeze dataclass

Bases: NotationTree, NotationStatement

Notation AST statement that freezes tns in the current scope after modifications with op.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Freeze(NotationTree, NotationStatement):
    """
    Notation AST statement that freezes `tns` in the current scope after
    modifications with `op`.
    """

    tns: NotationExpression
    op: NotationExpression

    @property
    def children(self):
        return [self.tns, self.op]

Full dataclass

Bases: NotationTree, NotationExpression

A read-only tensor filled with val, with scalar shape by default.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Full(NotationTree, NotationExpression):
    """A read-only tensor filled with `val`, with scalar shape by default."""

    val: NotationExpression
    shape: tuple[NotationExpression, ...] = ()

    @property
    def result_type(self):
        match self.val:
            case Literal(val):
                fill_type = StaticFillFType(val)
            case _:
                fill_type = DynamicFillFType(self.val.result_type)
        return tensor.patterns.FillTensorFType(
            fill_type,
            self.val.result_type,
            tuple(dim.result_type for dim in self.shape),
        )

    @classmethod
    def from_children(cls, val, *shape):
        return cls(val, tuple(shape))

    @property
    def children(self):
        return [self.val, *self.shape]

Function dataclass

Bases: NotationTree

A module-level function definition with arguments args....

Attributes:

Name	Type	Description
name	Variable	The function variable, annotated with its AssemblyKernelFType.
args	tuple[Variable, ...]	The arguments to the function.
body	NotationStatement	The body of the function. If it does not contain a return statement, the function returns the value of body.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Function(NotationTree):
    """
    A module-level function definition with arguments `args...`.

    Attributes:
        name: The function variable, annotated with its AssemblyKernelFType.
        args: The arguments to the function.
        body: The body of the function. If it does not contain a return statement,
            the function returns the value of `body`.
    """

    name: Variable
    args: tuple[Variable, ...]
    body: NotationStatement

    @property
    def children(self):
        """Returns the children of the node."""
        return [self.name, *self.args, self.body]

    @classmethod
    def from_children(cls, name, *args_body):
        """Creates a term with the given head and arguments."""
        *args, body = args_body
        return cls(name, tuple(args), body)

children property

Returns the children of the node.

from_children(name, *args_body) classmethod

Creates a term with the given head and arguments.

Source code in src/finch/finch_notation/nodes.py

@classmethod
def from_children(cls, name, *args_body):
    """Creates a term with the given head and arguments."""
    *args, body = args_body
    return cls(name, tuple(args), body)

HollowFiber dataclass

Bases: Fiber

A candidate sparse fiber, recording whether a non-fill value was written.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class HollowFiber(Fiber):
    """A candidate sparse fiber, recording whether a non-fill value was written."""

    dirty: Variable = field(kw_only=True)

    @property
    def children(self):
        return [self.lvl, self.pos, self.dirty, *self.idxs]

    @classmethod
    def from_children(cls, lvl, pos, dirty, *idxs):
        return cls(lvl, pos, idxs, dirty=dirty)

If dataclass

Bases: NotationTree, NotationStatement

Notation AST statement that only executes body if cond is true.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class If(NotationTree, NotationStatement):
    """
    Notation AST statement that only executes `body` if `cond` is true.
    """

    cond: NotationExpression
    body: NotationStatement

    @property
    def children(self):
        return [self.cond, self.body]

IfElse dataclass

Bases: NotationTree, NotationStatement

Notation AST statement that executes then_body if cond is true, otherwise executes else_body.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class IfElse(NotationTree, NotationStatement):
    """
    Notation AST statement that executes `then_body` if `cond` is true, otherwise
    executes `else_body`.
    """

    cond: NotationExpression
    then_body: NotationStatement
    else_body: NotationStatement

    @property
    def children(self):
        return [self.cond, self.then_body, self.else_body]

Increment dataclass

Bases: NotationTree, NotationStatement

Notation AST statement that updates the value lhs using rhs.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Increment(NotationTree, NotationStatement):
    """
    Notation AST statement that updates the value `lhs` using `rhs`.
    """

    lhs: Access
    rhs: NotationExpression

    @property
    def children(self):
        return [self.lhs, self.rhs]

Literal dataclass

Bases: NotationExpression, LiteralTerm

Notation AST expression for the literal value val.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Literal(NotationExpression, LiteralTerm):
    """
    Notation AST expression for the literal value `val`.
    """

    @property
    def result_type(self):
        return ftype(self.val)

    def __repr__(self) -> str:
        return literal_repr(type(self).__name__, {"val": self.val})

Loop dataclass

Bases: NotationTree, NotationStatement

Notation AST statement that runs body for each value of idx in ext.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Loop(NotationTree, NotationStatement):
    """
    Notation AST statement that runs `body` for each value of `idx` in `ext`.
    """

    idx: Variable
    ext: NotationExpression
    body: NotationStatement

    @property
    def children(self):
        return [self.idx, self.ext, self.body]

Looplet dataclass

Bases: NotationExpression

A typed tensor expression being lowered by a looplet pass.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Looplet(NotationExpression):
    """A typed tensor expression being lowered by a looplet pass."""

    body: LoopletImpl
    type_: TensorFType

    @property
    def result_type(self) -> TensorFType:
        return self.type_

Module dataclass

Bases: NotationTree

Represents a group of functions. This is the toplevel translation unit for FinchNotation.

Attributes:

Name	Type	Description
funcs	tuple[Function, ...]	The functions defined in the module.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Module(NotationTree):
    """
    Represents a group of functions. This is the toplevel translation unit for
    FinchNotation.

    Attributes:
        funcs: The functions defined in the module.
    """

    funcs: tuple[Function, ...]

    @property
    def children(self):
        """Returns the children of the node."""
        return [*self.funcs]

    @classmethod
    def from_children(cls, *funcs):
        return cls(funcs)

children property

Returns the children of the node.

NotationExpression dataclass

Bases: NotationNode, ExpressionTerm

Notation AST expression base class.

A Notation expression is a program node which evaluates to a value.

Source code in src/finch/finch_notation/nodes.py

class NotationExpression(NotationNode, ExpressionTerm):
    """
    Notation AST expression base class.

    A Notation expression is a program node which evaluates to a value.
    """

    @property
    @abstractmethod
    def result_type(self) -> FType:
        """
        Get the type of the expression.
        """
        ...

result_type abstractmethod property

Get the type of the expression.

NotationNode dataclass

Bases: Term, ABC

NotationNode

Base class for all Finch Notation nodes

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class NotationNode(Term, ABC):
    """
    NotationNode

    Base class for all Finch Notation nodes
    """

    @classmethod
    def head(cls):
        """Returns the head of the node."""
        return cls

    @classmethod
    def make_term(cls, head, *children):
        return head.from_children(*children)

    @classmethod
    def from_children(cls, *children):
        return cls(*children)

    def __str__(self):
        """Returns a string representation of the node."""
        ctx = NotationPrinterContext()
        res = ctx(self)
        return res if res is not None else ctx.emit()

__str__()

Returns a string representation of the node.

Source code in src/finch/finch_notation/nodes.py

def __str__(self):
    """Returns a string representation of the node."""
    ctx = NotationPrinterContext()
    res = ctx(self)
    return res if res is not None else ctx.emit()

head() classmethod

Returns the head of the node.

Source code in src/finch/finch_notation/nodes.py

@classmethod
def head(cls):
    """Returns the head of the node."""
    return cls

NotationStatement dataclass

Bases: NotationNode

Notation AST statement base class.

A Notation statement is a program node nested inside a function which does not produce a value, but may modify the state of the machine.

Source code in src/finch/finch_notation/nodes.py

class NotationStatement(NotationNode):
    """
    Notation AST statement base class.

    A Notation statement is a program node nested inside a function which does
    not produce a value, but may modify the state of the machine.
    """

Read dataclass

Bases: AccessMode

Notation AST node representing a read-only access mode for a tensor. This mode allows reading the value of a tensor without modifying it.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Read(AccessMode):
    """
    Notation AST node representing a read-only access mode for a tensor.
    This mode allows reading the value of a tensor without modifying it.
    """

    @property
    def children(self):
        return []

Repack dataclass

Bases: NotationTree, NotationStatement

Registers updates from a symbolic object val with the original object obj. The original object may now be accessed and modified.

Attributes:

Name	Type	Description
slot		The symbolic object to read from.
obj	NotationExpression	The original object to write to.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Repack(NotationTree, NotationStatement):
    """
    Registers updates from a symbolic object `val` with the original
    object `obj`. The original object may now be accessed and modified.

    Attributes:
        slot: The symbolic object to read from.
        obj: The original object to write to.
    """

    val: Slot
    obj: NotationExpression

    @property
    def children(self):
        """Returns the children of the node."""
        return [self.val, self.obj]

children property

Returns the children of the node.

Return dataclass

Bases: NotationTree, NotationStatement

Notation AST statement that returns the value of val from the current function.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Return(NotationTree, NotationStatement):
    """
    Notation AST statement that returns the value of `val` from the current
    function.
    """

    val: NotationExpression

    @property
    def children(self):
        """Returns the children of the node."""
        return [self.val]

    @classmethod
    def from_children(cls, val):
        return cls(val)

children property

Returns the children of the node.

Root dataclass

Bases: NotationTree, Cursor

The first level of a tensor.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Root(NotationTree, Cursor):
    """The first level of a tensor."""

    tns: NotationExpression

    @property
    def root(self):
        return self.tns

    @property
    def result_type(self):
        return cast("FinchTensorFType", self.tns.result_type).get_child_type("lvl")

    @property
    def children(self):
        return [self.tns]

Slot dataclass

Bases: NotationExpression, NamedTerm

Represents a register to a symbolic object. Using a register in an expression creates a copy of the object.

Attributes:

Name	Type	Description
name	str	The name of the symbolic object to register.
type	FType	The type of the symbolic object.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Slot(NotationExpression, NamedTerm):
    """
    Represents a register to a symbolic object. Using a register in an
    expression creates a copy of the object.

    Attributes:
        name: The name of the symbolic object to register.
        type: The type of the symbolic object.
    """

    name: str
    type: FType

    @property
    def result_type(self):
        """Returns the type of the expression."""
        return self.type

    def __repr__(self) -> str:
        return literal_repr(type(self).__name__, {"name": self.name, "type": self.type})

    @property
    def symbol(self) -> str:
        return self.name

result_type property

Returns the type of the expression.

Thaw dataclass

Bases: NotationTree, NotationStatement

Notation AST statement that thaws tns in the current scope, moving the tensor from read-only mode to update-only mode with a reduction operator op.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Thaw(NotationTree, NotationStatement):
    """
    Notation AST statement that thaws `tns` in the current scope, moving the tensor
    from read-only mode to update-only mode with a reduction operator `op`.
    """

    tns: NotationExpression
    op: NotationExpression

    @property
    def children(self):
        return [self.tns, self.op]

Unpack dataclass

Bases: NotationTree, NotationStatement

Attempts to convert rhs into a symbolic, which can be registerd with lhs. The original object must not be accessed or modified until the corresponding Repack node is reached.

Attributes:

Name	Type	Description
lhs	Slot	The symbolic object to write to.
rhs	NotationExpression	The original object to read from.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Unpack(NotationTree, NotationStatement):
    """
    Attempts to convert `rhs` into a symbolic, which can be registerd with
    `lhs`. The original object must not be accessed or modified until the
    corresponding `Repack` node is reached.

    Attributes:
        lhs: The symbolic object to write to.
        rhs: The original object to read from.
    """

    lhs: Slot
    rhs: NotationExpression

    @property
    def children(self):
        """Returns the children of the node."""
        return [self.lhs, self.rhs]

children property

Returns the children of the node.

Unwrap dataclass

Bases: NotationTree, NotationExpression

Notation AST statement that unwraps the scalar value from a 0-dimensional tensor arg.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Unwrap(NotationTree, NotationExpression):
    """
    Notation AST statement that unwraps the scalar value from a 0-dimensional
    tensor `arg`.
    """

    arg: NotationExpression

    @property
    def children(self):
        return [self.arg]

    @property
    def result_type(self):
        """
        Returns the type of the unwrapped value.
        """
        assert isinstance(self.arg.result_type, TensorFType)
        return self.arg.result_type.element_type

result_type property

Returns the type of the unwrapped value.

Update dataclass

Bases: AccessMode, NotationTree

Notation AST node representing an update access mode for a tensor. This mode allows reading and modifying the value of a tensor. Increment operations are allowed in this mode, and will use the update operation op to increment ref with val as ref = op(ref, val). To overwrite the value of a tensor, use the ops algebra.overwrite or algebra.init_write. Attributes: op: The operation used to update the value of the tensor.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Update(AccessMode, NotationTree):
    """
    Notation AST node representing an update access mode for a tensor.  This
    mode allows reading and modifying the value of a tensor.  Increment
    operations are allowed in this mode, and will use the update operation `op`
    to increment `ref` with `val` as `ref = op(ref, val)`.  To overwrite the
    value of a tensor, use the ops `algebra.overwrite` or `algebra.init_write`.
    Attributes:
        op: The operation used to update the value of the tensor.
    """

    op: NotationExpression

    @property
    def children(self):
        return [self.op]

Value dataclass

Bases: NotationExpression

Notation AST expression for host code val expected to evaluate to a value of type type_.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Value(NotationExpression):
    """
    Notation AST expression for host code `val` expected to evaluate to a value of
    type `type_`.
    """

    ex: AssemblyExpression
    type_: FType

    @property
    def result_type(self):
        return self.type_

    def __repr__(self) -> str:
        return literal_repr(type(self).__name__, {"ex": self.ex, "type_": self.type_})

Variable dataclass

Bases: NotationExpression, NamedTerm

Notation AST expression for a variable named name.

Attributes:

Name	Type	Description
name	str	The name of the variable.
type_	FType	The type of the variable.

Source code in src/finch/finch_notation/nodes.py

@dataclass(eq=True, frozen=True)
class Variable(NotationExpression, NamedTerm):
    """
    Notation AST expression for a variable named `name`.

    Attributes:
        name: The name of the variable.
        type_: The type of the variable.
    """

    name: str
    type_: FType

    def __post_init__(self):
        assert isinstance(self.type_, FType)

    @property
    def result_type(self):
        return self.type_

    def __repr__(self) -> str:
        return literal_repr(
            type(self).__name__, {"name": self.name, "type_": self.type_}
        )

    @property
    def symbol(self) -> str:
        return self.name