# `Beaver.MLIR.Operation`

This module defines functions working with MLIR Operation.

# `equivalence_option`

```elixir
@type equivalence_option() ::
  {:ignore_locations, boolean()}
  | {:ignore_discardable_attributes, boolean()}
  | {:ignore_properties, boolean()}
  | {:ignore_commutativity, boolean()}
```

Options shared by structural equivalence and structural hashing.

# `equivalence_options`

```elixir
@type equivalence_options() :: [equivalence_option()]
```

# `t`

```elixir
@type t() :: %Beaver.MLIR.Operation{ref: term()}
```

# `clone`

# `create`

# `destroy`

# `equivalent?`

```elixir
@spec equivalent?(t(), t(), equivalence_options()) :: boolean()
```

Tests two operations for structural equivalence without printing or parsing.

The default comparison includes locations, discardable attributes,
properties, and commutative operand ordering. Set an option to `true` to
ignore that part of the comparison. In particular,
`ignore_commutativity: true` makes operand comparison order-sensitive; this
mirrors MLIR's `IgnoreCommutativity` flag.

# `eval_ssa`

Evaluate the SSA and return the operation or its results based on the defined result types.

Normalize the results of the given operation in the following way:
- If the operation has no result, return the operation itself.
- If the operation has one result, return that result.
- If the operation has multiple results, return a list of results.

# `from_module`

# `implements_interface?`

# `infer_shaped?`

# `infer_type?`

# `location`

# `make`

# `name`

# `parent`

# `result`

# `results`

# `structural_hash`

```elixir
@spec structural_hash(t(), equivalence_options()) :: non_neg_integer()
```

Computes MLIR's structural hash for an operation.

Use the same options as `equivalent?/3`: operations equivalent under the
same options have equal hashes. The converse is not guaranteed. MLIR hashes
external operands by identity, omits results, and does not include regions,
so this is intended for bucketing before an equivalence check rather than as
a complete content digest.

# `terminator?`

Check if the operation is a terminator.

# `with_symbol_table`