chip

Chip is a gleam process registry that plays along gleam erlang/OTP Subject type.

It lets us group subjects of the same type so that we can later reference them all as a group, or sub-group if we decide to name them. Will also automatically delist dead processes.

Example

Lets assemble the pieces to build a simple counter actor:

pub type CounterMessage {
 Inc
 Current(client: process.Subject(Int))
 Stop(client: process.Subject(Int))
}

fn handle_count(message: CounterMessage, count: Int) {
 case message {
   Inc -> {
     actor.continue(count + 1)
   }

   Current(client) -> {
     process.send(client, count)
     actor.continue(count)
   }

   Stop(client) -> {
     process.send(client, count)
     actor.Stop(process.Normal)
   }
 }
}

We start our registry and create new instances of a counter:

import gleam/erlang/process
import chip

pub fn main() {
 let assert Ok(registry) = chip.start()

 chip.register(registry, fn() { 
   actor.start(1, handle_count)
 })
 
 chip.register(registry, fn() { 
   actor.start(2, handle_count)
 })
 
 chip.register(registry, fn() { 
   actor.start(3, handle_count)
 })
}

Then retrieve all registered subjects so we can send messages:

chip.all(registry) 
|> list.each(process.send(_, Inc))

let assert [2, 3, 4] =  
 chip.all(registry)
 |> list.map(process.call(_, Current(_), 10))
 |> list.sort(int.compare)

It is also possible to register a subject under a named subgroup:

import gleam/erlang/process
import chip

type Group {
 GroupA 
 GroupB 
}

pub fn main() {
 let assert Ok(registry) = chip.start()

 chip.register_as(registry, GroupA, fn() { 
   actor.start(1, handle_count)
 })
 
 chip.register(registry, GroupB, fn() { 
   actor.start(2, handle_count)
 })
 
 chip.register(registry, GroupA, fn() { 
   actor.start(3, handle_count)
 })
}

Then lookup for specific names under the group:

let assert [1, 3] = 
 chip.lookup(registry, GroupA) 
 |> list.map(process.call(_, Current(_), 10))
 |> list.sort(int.compare)

Feature-wise this is near beign complete. Still planning to integrate:

• A via helper to initialize processes explicitly, currently register and register_as).
• A register helper to implicitly initialize subjects.
• Pending to document guides and use-cases.

Installation

gleam add chip