glixir/registry

Type-safe, phantom-typed Registry for Gleam/Elixir interop

This module provides a phantom-typed interface to Elixir Registry. All registries are parameterized by their key_type and message_type, so misuse is a compile error, not a runtime surprise.

Types

KeyEncoder

</>

pub type KeyEncoder(key_type) =
  fn(key_type) -> String

Registry

opaque </>

Opaque phantom-typed registry

pub opaque type Registry(key_type, message_type)

RegistryError

</>

Errors from registry operations

pub type RegistryError {
  StartError(String)
  RegisterError(String)
  LookupError(String)
  UnregisterError(String)
  AlreadyExists
  NotFound
}

Constructors

```
StartError(String)
```
```
RegisterError(String)
```
```
LookupError(String)
```
```
UnregisterError(String)
```
```
AlreadyExists
```
```
NotFound
```

RegistryKeys

</>

Registry configuration options

pub type RegistryKeys {
  Unique
  Duplicate
}

Constructors

```
Unique
```
```
Duplicate
```

RegistryLookupResult

</>

pub type RegistryLookupResult(message) {
  RegistryLookupOk(subject: process.Subject(message))
  RegistryLookupNotFound
  RegistryLookupError(reason: dynamic.Dynamic)
}

Constructors

RegistryLookupOk(subject: process.Subject(message))

```
RegistryLookupNotFound
```

RegistryLookupError(reason: dynamic.Dynamic)

RegistryRegisterResult

</>

pub type RegistryRegisterResult {
  RegistryRegisterOk
  RegistryRegisterError(reason: dynamic.Dynamic)
}

Constructors

```
RegistryRegisterOk
```

RegistryRegisterError(reason: dynamic.Dynamic)

RegistryStartResult

</>

pub type RegistryStartResult {
  RegistryStartOk(pid: process.Pid)
  RegistryStartError(reason: dynamic.Dynamic)
}

Constructors

```
RegistryStartOk(pid: process.Pid)
```

RegistryStartError(reason: dynamic.Dynamic)

RegistryUnregisterResult

</>

pub type RegistryUnregisterResult {
  RegistryUnregisterOk
  RegistryUnregisterError(reason: dynamic.Dynamic)
}

Constructors

```
RegistryUnregisterOk
```

RegistryUnregisterError(reason: dynamic.Dynamic)

Values

atom_key_encoder

</>

pub fn atom_key_encoder(key: atom.Atom) -> String

Encoder for Atom keys (most common case)

int_key_encoder

</>

pub fn int_key_encoder(key: Int) -> String

Encoder for Int keys

lookup_subject

</>

pub fn lookup_subject(
  registry_name: atom.Atom,
  key: key_type,
  encode_key: fn(key_type) -> String,
) -> Result(process.Subject(message_type), RegistryError)

Look up a Subject by typed key in the phantom-typed registry

register_subject

</>

pub fn register_subject(
  registry_name: atom.Atom,
  key: key_type,
  subject: process.Subject(message_type),
  encode_key: fn(key_type) -> String,
) -> Result(Nil, RegistryError)

session_key_encoder

</>

pub fn session_key_encoder(session_id: String) -> String

Encoder for session keys (common pattern)

start_registry

</>

pub fn start_registry(
  name: atom.Atom,
  keys: RegistryKeys,
) -> Result(Registry(key_type, message_type), RegistryError)

Start a phantom-typed registry with bounded key and message types

start_unique_registry

</>

pub fn start_unique_registry(
  name: atom.Atom,
) -> Result(Registry(key_type, message_type), RegistryError)

Start a unique key registry (most common use case)

string_key_encoder

</>

pub fn string_key_encoder(key: String) -> String

Encoder for String keys

unregister_subject

</>

pub fn unregister_subject(
  registry_name: atom.Atom,
  key: key_type,
  encode_key: fn(key_type) -> String,
) -> Result(Nil, RegistryError)

Unregister a key from the phantom-typed registry

user_id_encoder

</>

pub fn user_id_encoder(user_id: Int) -> String

Encoder for user ID keys (common pattern)