# `RustQ.Rustler.Opts`
[🔗](https://github.com/elixir-crab/rustq/blob/v1.0.0-rc.19/lib/rustq/rustler/opts.ex#L1)

Generates Rustler keyword/options structs, decoders, and option helper functions.

# `__mix_recompile__?`

Whether the module's Rust file appeared or went since the module compiled.

# `__rustq_asts__`

The RustQ AST of each `defrust` definition.

# `__rustq_callables__`

Callable metadata for the module's definitions.

# `__rustq_items__`

The Rust items the module generates, in order.

# `__rustq_macro_definitions__`

The module's `defrustmacro` definitions.

# `__rustq_macro_items__`

The `macro_rules!` items `defrustmacro` emits.

# `__rustq_rust_modules__`

The Rust modules the module's `defrustmod`s map its aliases, or itself (`[]`), to.

# `__rustq_source__`

The Rust source the module generates.

# `__rustq_type_asts__`

The RustQ AST of each declared Rust type.

# `__rustq_type_items__`

The Rust items the module's types generate.

# `__rustq_types__`

The Rust types the module's `@type`s declare.

# `decode_args`

```elixir
@spec decode_args(term()) :: RustQ.Type.nif_result(RustQ.Type.vec(term()))
```

A Rust function `defrust` generates. It runs only as Rust; calling it from Elixir
raises.

# `decode_opts`

```elixir
@spec decode_opts(term()) ::
  RustQ.Type.nif_result(RustQ.Type.vec({RustQ.Type.path(:Atom), term()}))
```

A Rust function `defrust` generates. It runs only as Rust; calling it from Elixir
raises.

# `decoder`

```elixir
@spec decoder(
  atom() | String.t(),
  keyword()
) :: [RustQ.Rust.AST.Struct.t() | RustQ.Rust.AST.Function.t()]
```

Builds an options struct and its decoder from structural field metadata.

# `helpers`

```elixir
@spec helpers(keyword()) :: [RustQ.Rust.AST.Function.t()]
```

Builds reusable keyword/options decoding helpers.

# `opt_atom_option`

```elixir
@spec opt_atom_option(
  RustQ.Type.slice({RustQ.Type.path(:Atom), term()}),
  RustQ.Type.path(:Atom)
) ::
  RustQ.Type.nif_result(RustQ.Type.option(RustQ.Type.path(:Atom)))
```

A Rust function `defrust` generates. It runs only as Rust; calling it from Elixir
raises.

# `opt_bool_option`

```elixir
@spec opt_bool_option(
  RustQ.Type.slice({RustQ.Type.path(:Atom), term()}),
  RustQ.Type.path(:Atom)
) ::
  RustQ.Type.nif_result(RustQ.Type.option(boolean()))
```

A Rust function `defrust` generates. It runs only as Rust; calling it from Elixir
raises.

# `opt_f32`

```elixir
@spec opt_f32(
  RustQ.Type.slice({RustQ.Type.path(:Atom), term()}),
  RustQ.Type.path(:Atom)
) ::
  RustQ.Type.nif_result(RustQ.Type.f32())
```

A Rust function `defrust` generates. It runs only as Rust; calling it from Elixir
raises.

# `opt_f32_default`

```elixir
@spec opt_f32_default(
  RustQ.Type.slice({RustQ.Type.path(:Atom), term()}),
  RustQ.Type.path(:Atom),
  RustQ.Type.f32()
) :: RustQ.Type.nif_result(RustQ.Type.f32())
```

A Rust function `defrust` generates. It runs only as Rust; calling it from Elixir
raises.

# `opt_f32_option`

```elixir
@spec opt_f32_option(
  RustQ.Type.slice({RustQ.Type.path(:Atom), term()}),
  RustQ.Type.path(:Atom)
) ::
  RustQ.Type.nif_result(RustQ.Type.option(RustQ.Type.f32()))
```

A Rust function `defrust` generates. It runs only as Rust; calling it from Elixir
raises.

# `opt_term`

```elixir
@spec opt_term(
  RustQ.Type.slice({RustQ.Type.path(:Atom), term()}),
  RustQ.Type.path(:Atom)
) ::
  RustQ.Type.option(term())
```

A Rust function `defrust` generates. It runs only as Rust; calling it from Elixir
raises.

---

*Consult [api-reference.md](api-reference.md) for complete listing*