# `Errow.Binary`
[🔗](https://github.com/kuku/errow/blob/v0.1.0/lib/errow/binary.ex#L1)

An immutable, continuous-memory binary array implementing the Apache Arrow `Binary` columnar format (for raw byte blobs).

Under the hood, data is organized in three buffers:
  1. **Offsets buffer** (`offsets`): a continuous binary of 32-bit signed integers in little-endian.
  2. **Data buffer** (`data`): a continuous binary containing the concatenated raw byte blobs.
  3. **Validity bitmap** (`validity`): a bitstring tracking null (`nil`) values (1 bit per element).

Unlike `Errow.String`, `Errow.Binary` is meant for opaque byte slices, hashes, PNG/JPEG payloads,
UUIDs, Protobuf blobs, etc.

# `t`

```elixir
@type t() :: %Errow.Binary{
  data: binary(),
  length: non_neg_integer(),
  null_count: non_neg_integer(),
  offsets: binary(),
  validity: bitstring()
}
```

# `append`

```elixir
@spec append(t(), binary() | nil) :: t()
```

Appends a binary blob or `nil` to the array.

# `buffer_byte_size`

```elixir
@spec buffer_byte_size(t()) :: non_neg_integer()
```

Returns the byte size of the continuous data buffer.

# `delete_at`

```elixir
@spec delete_at(t(), integer()) :: t()
```

Deletes the element at index `idx`.

# `fetch`

```elixir
@spec fetch(t(), integer() | Range.t()) :: {:ok, any()} | :error
```

Fetches the element at the given index or a slice specified by a range.
Supports negative indices (e.g. `-1` for the last element).

# `from_list`

```elixir
@spec from_list(Enumerable.t()) :: t()
```

Builds an `Errow.Binary` array from a list or enumerable of binaries and optional `nil`s.

# `get`

```elixir
@spec get(t(), integer(), any()) :: binary() | nil | any()
```

Gets the value at index `idx` or returns `default` if out of bounds.

# `new`

```elixir
@spec new() :: t()
```

Creates a new empty `Errow.Binary` array.

# `null?`

```elixir
@spec null?(t(), integer()) :: boolean()
```

Checks if the value at the given index is null (`nil`).

# `null_count`

```elixir
@spec null_count(t()) :: non_neg_integer()
```

Returns the count of null values.

# `replace_at`

```elixir
@spec replace_at(t(), integer(), binary() | nil) :: t()
```

Replaces the element at the given index with a new binary blob or `nil`.

# `size`

```elixir
@spec size(t()) :: non_neg_integer()
```

Returns the number of elements in the array.

# `to_list`

```elixir
@spec to_list(t()) :: [binary() | nil]
```

Converts the `Errow.Binary` array into a standard Elixir list.

---

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