# `KiwiCodec.RustlerGenerator.Skip.Helpers`
[🔗](https://github.com/open-pencil/kiwi_codec/blob/v0.7.0/codegen/kiwi_codec/rustler_generator/skip/helpers.ex#L2)

Skip decoders: they read past a value without building a term, for callers projecting a
few fields out of a large message.

`kiwi_skip_struct_decoder!` defines a struct's skip decoder. A message's comes from
`KiwiCodec.RustlerGenerator.Skip.Messages`, or with sparse decoders from
`KiwiCodec.RustlerGenerator.Sparse.SkipMessages`. An enum is skipped as the `uint` it is
on the wire.

# `kiwi_skip_field`

```elixir
@type kiwi_skip_field() :: %{id: RustQ.Type.u32(), kind: kiwi_skip_kind()}
```

The Rust `KiwiSkipField`: a message field id and how to skip its value.

# `kiwi_skip_fn`

```elixir
@type kiwi_skip_fn() :: RustQ.Type.raw(:"fn(&mut Decoder<'_>) -> NifResult<()>")
```

The Rust `KiwiSkipFn`: skips one value of a type.

# `kiwi_skip_kind`

```elixir
@type kiwi_skip_kind() ::
  RustQ.Type.enum(one: [kiwi_skip_fn()], repeated: [kiwi_skip_fn()], bytes: [])
```

The Rust `KiwiSkipKind`: how a field's value is skipped, once, repeated, or as bytes.

# `__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.

# `kiwi_skip_bool_value`

```elixir
@spec kiwi_skip_bool_value(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_)))
) ::
  RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_byte_value`

```elixir
@spec kiwi_skip_byte_value(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_)))
) ::
  RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_bytes_value`

```elixir
@spec kiwi_skip_bytes_value(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_)))
) ::
  RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_descriptor_kind`

```elixir
@spec kiwi_skip_descriptor_kind(RustQ.Type.bool(), RustQ.Type.bool(), kiwi_skip_fn()) ::
  kiwi_skip_kind()
```

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

# `kiwi_skip_float_value`

```elixir
@spec kiwi_skip_float_value(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_)))
) ::
  RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_int64_value`

```elixir
@spec kiwi_skip_int64_value(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_)))
) ::
  RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_int_value`

```elixir
@spec kiwi_skip_int_value(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_)))
) ::
  RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_kind`

```elixir
@spec kiwi_skip_kind(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_))),
  RustQ.Type.ref(kiwi_skip_kind())
) :: RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_message_fields`

```elixir
@spec kiwi_skip_message_fields(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_))),
  RustQ.Type.str(),
  RustQ.Type.slice(kiwi_skip_field())
) :: RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_repeated`

```elixir
@spec kiwi_skip_repeated(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_))),
  kiwi_skip_fn()
) :: RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_string_value`

```elixir
@spec kiwi_skip_string_value(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_)))
) ::
  RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_struct_fields`

```elixir
@spec kiwi_skip_struct_fields(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_))),
  RustQ.Type.slice(kiwi_skip_kind())
) :: RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_uint64_value`

```elixir
@spec kiwi_skip_uint64_value(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_)))
) ::
  RustQ.Type.nif_result(RustQ.Type.unit())
```

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

# `kiwi_skip_uint_value`

```elixir
@spec kiwi_skip_uint_value(
  RustQ.Type.mut_ref(RustQ.Type.path(:Decoder, RustQ.Type.lifetime(:_)))
) ::
  RustQ.Type.nif_result(RustQ.Type.unit())
```

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*