# `Beaver.SSA`

Storing MLIR IR structure with a Elixir struct. Macros like `Beaver.mlir/1` will generate SSA structs defined by this module.

Semantically a SSA has no concept of "current block" or "current context". These are only needed when creating an operation.
Therefore SSA syntax in Beaver can be used in both IR-generating and PDL-generating.
To be more specific, the macro system in Beaver will use an SSA and its surrounding environment to construct a operation changeset,
and then create an operation from it by calling MLIR CAPI.

# `argument_entry`

```elixir
@type argument_entry() :: Beaver.Changeset.argument()
```

# `evaluator`

```elixir
@type evaluator() :: (t() -> term())
```

# `filler_fun`

```elixir
@type filler_fun() :: (-> term())
```

# `insertion_point`

```elixir
@type insertion_point() ::
  Beaver.MLIR.Block.t()
  | Beaver.MLIR.PatternRewriter.t()
  | Beaver.MLIR.RewriterBase.t()
  | nil
```

# `op_result_entry`

```elixir
@type op_result_entry() ::
  {:op, Beaver.Changeset.result() | [Beaver.Changeset.result()]}
```

# `result_entry`

```elixir
@type result_entry() :: Beaver.Changeset.result() | :infer | op_result_entry()
```

# `t`

```elixir
@type t() :: %Beaver.SSA{
  arguments: [argument_entry()],
  ctx: Beaver.MLIR.Context.t() | nil,
  evaluator: evaluator() | nil,
  filler: filler_fun() | nil,
  ip: insertion_point(),
  loc: Beaver.MLIR.Location.t() | nil,
  op: String.t() | nil,
  results: :infer | [result_entry()]
}
```

# `eval`

# `postwalk`

# `prewalk`

# `put_arguments`

# `put_ctx`

# `put_filler`

# `put_ip`

# `put_location`

# `put_results`