slate - v0.1.0

slate/bag

Types

Bag

opaque </>

An open DETS bag table with typed keys and values.

pub opaque type Bag(k, v)

Values

close

</> 
pub fn close(table: Bag(k, v)) -> Result(Nil, slate.DetsError)

Close the table, flushing all pending writes to disk.

delete_all

</> 
pub fn delete_all(
  from table: Bag(k, v),
) -> Result(Nil, slate.DetsError)

Delete all objects in the table (keeps the table open).

delete_key

</> 
pub fn delete_key(
  from table: Bag(k, v),
  key key: k,
) -> Result(Nil, slate.DetsError)

Delete all values for the given key.

delete_object

</> 
pub fn delete_object(
  from table: Bag(k, v),
  key key: k,
  value value: v,
) -> Result(Nil, slate.DetsError)

Delete a specific key-value pair from the table.

Only the exact matching pair is removed. Other values for the same key are preserved. This is the primary way to remove individual values from a bag without affecting other entries for the same key.

import gleam/dynamic/decode
let assert Ok(table) = bag.open("tags.dets",
  key_decoder: decode.string, value_decoder: decode.string)
let assert Ok(Nil) = bag.insert(table, "color", "red")
let assert Ok(Nil) = bag.insert(table, "color", "blue")
let assert Ok(Nil) = bag.delete_object(table, "color", "red")
let assert Ok(["blue"]) = bag.lookup(table, "color")

fold

</> 
pub fn fold(
  over table: Bag(k, v),
  from initial: acc,
  with fun: fn(acc, k, v) -> acc,
) -> Result(acc, slate.DetsError)

Fold over all entries. Order is unspecified.

Returns Error(DecodeErrors(_)) if any entry doesn’t match the expected types. The fold stops at the first decode error.

info

</> 
pub fn info(
  table: Bag(k, v),
) -> Result(slate.TableInfo, slate.DetsError)

Get information about an open table.

insert

</> 
pub fn insert(
  into table: Bag(k, v),
  key key: k,
  value value: v,
) -> Result(Nil, slate.DetsError)

Insert a key-value pair. Returns Error(KeyAlreadyPresent) if the exact key-value pair already exists in the table.

Note: Native DETS dets:insert on a bag silently deduplicates identical objects. Slate makes duplicates explicit so callers can detect no-op inserts. Use insert_list for batch inserts that follow the native DETS silent-dedup behavior.

insert_list

</> 
pub fn insert_list(
  into table: Bag(k, v),
  entries entries: List(#(k, v)),
) -> Result(Nil, slate.DetsError)

Insert multiple key-value pairs.

Unlike insert, this uses the native DETS batch insert, which silently deduplicates any key-value pair that already exists in the table. Use this for efficient bulk loading where duplicate detection is not needed.

lookup

</> 
pub fn lookup(
  from table: Bag(k, v),
  key key: k,
) -> Result(List(v), slate.DetsError)

Look up all values for a key. Returns an empty list if key not found.

Returns Error(DecodeErrors(_)) if any stored value doesn’t match the expected type.

member

</> 
pub fn member(
  of table: Bag(k, v),
  key key: k,
) -> Result(Bool, slate.DetsError)

Check if a key exists without returning the values.

open

</> 
pub fn open(
  path: String,
  key_decoder key_decoder: decode.Decoder(k),
  value_decoder value_decoder: decode.Decoder(v),
) -> Result(Bag(k, v), slate.DetsError)

Open or create a DETS bag table at the given file path.

Decoders are used to validate data read from disk, ensuring type safety even when opening files created by other code or previous runs.

import gleam/dynamic/decode
let assert Ok(table) = bag.open("data/tags.dets",
  key_decoder: decode.string, value_decoder: decode.string)

open_with

</> 
pub fn open_with(
  path: String,
  repair: slate.RepairPolicy,
  key_decoder key_decoder: decode.Decoder(k),
  value_decoder value_decoder: decode.Decoder(v),
) -> Result(Bag(k, v), slate.DetsError)

Open or create a DETS bag table with repair options.

open_with_access

</> 
pub fn open_with_access(
  path: String,
  repair: slate.RepairPolicy,
  access: slate.AccessMode,
  key_decoder key_decoder: decode.Decoder(k),
  value_decoder value_decoder: decode.Decoder(v),
) -> Result(Bag(k, v), slate.DetsError)

Open a DETS bag table with repair and access mode options.

Use ReadOnly to open a table for reading only. Write operations on a read-only table will return Error(AccessDenied).

import gleam/dynamic/decode
let assert Ok(table) = bag.open_with_access(path, AutoRepair, ReadOnly,
  key_decoder: decode.string, value_decoder: decode.string)
let assert Ok(vals) = bag.lookup(table, key: "key")
// bag.insert(table, "key", "val") would return Error(AccessDenied)

size

</> 
pub fn size(of table: Bag(k, v)) -> Result(Int, slate.DetsError)

Return the number of objects stored.

sync

</> 
pub fn sync(table: Bag(k, v)) -> Result(Nil, slate.DetsError)

Flush pending writes to disk without closing the table.

to_list

</> 
pub fn to_list(
  from table: Bag(k, v),
) -> Result(List(#(k, v)), slate.DetsError)

Return all key-value pairs as a list.

Warning: loads entire table into memory. Returns Error(DecodeErrors(_)) if any entry doesn’t match the expected types.

with_table

</> 
pub fn with_table(
  path: String,
  key_decoder key_decoder: decode.Decoder(k),
  value_decoder value_decoder: decode.Decoder(v),
  fun fun: fn(Bag(k, v)) -> Result(a, slate.DetsError),
) -> Result(a, slate.DetsError)

Use a table within a callback, ensuring it is closed afterward.

This is the recommended way to use DETS tables for short-lived operations.

import gleam/dynamic/decode
use table <- bag.with_table("data/tags.dets",
  key_decoder: decode.string, value_decoder: decode.string)
bag.insert(table, "color", "red")
✨ Search Document