distribute - v3.0.0

distribute/global

Types

CallError

</> 
pub type CallError {
  CallTimeout
  CallEncodeFailed(codec.EncodeError)
  CallDecodeFailed(codec.DecodeError)
}

Constructors

GlobalSubject

opaque </>

A subject with a codec, usable across nodes.

pub opaque type GlobalSubject(msg)

Values

call

</> 
pub fn call(
  target: GlobalSubject(req),
  make_request: fn(process.Subject(BitArray)) -> req,
  response_decoder: fn(BitArray) -> Result(
    resp,
    codec.DecodeError,
  ),
  timeout_ms: Int,
) -> Result(resp, CallError)

Synchronous request/response. Creates a temporary subject, sends the request (built by make_request), waits for the reply. The handler must call reply with the same subject.

call_error_to_string

</> 
pub fn call_error_to_string(error: CallError) -> String

decoder

</> 
pub fn decoder(
  global: GlobalSubject(msg),
) -> fn(BitArray) -> Result(msg, codec.DecodeError)

encoder

</> 
pub fn encoder(
  global: GlobalSubject(msg),
) -> fn(msg) -> Result(BitArray, codec.EncodeError)

from_name

</> 
pub fn from_name(
  name: String,
  pid: process.Pid,
  encoder: fn(msg) -> Result(BitArray, codec.EncodeError),
  decoder: fn(BitArray) -> Result(msg, codec.DecodeError),
) -> GlobalSubject(msg)

Subject from a name and PID. The name is the tag, so any node that knows the name can reconstruct the same Subject.

from_pid

</> 
pub fn from_pid(
  pid: process.Pid,
  encoder: fn(msg) -> Result(BitArray, codec.EncodeError),
  decoder: fn(BitArray) -> Result(msg, codec.DecodeError),
) -> GlobalSubject(msg)

Subject from a remote PID. Nil tag, send-only — you can’t receive on it from the calling process.

from_subject

</> 
pub fn from_subject(
  subject: process.Subject(BitArray),
  encoder: fn(msg) -> Result(BitArray, codec.EncodeError),
  decoder: fn(BitArray) -> Result(msg, codec.DecodeError),
) -> GlobalSubject(msg)

Wrap an existing Subject(BitArray), keeping its tag.

new

</> 
pub fn new(
  encoder: fn(msg) -> Result(BitArray, codec.EncodeError),
  decoder: fn(BitArray) -> Result(msg, codec.DecodeError),
) -> GlobalSubject(msg)

New subject owned by the current process, with a unique tag.

owner

</> 
pub fn owner(
  global: GlobalSubject(msg),
) -> Result(process.Pid, Nil)

receive

</> 
pub fn receive(
  global: GlobalSubject(msg),
  timeout_ms: Int,
) -> Result(msg, codec.DecodeError)

Receive and decode a message. Only works on subjects you own.

reply

</> 
pub fn reply(
  reply_to: process.Subject(BitArray),
  response: resp,
  encoder: fn(resp) -> Result(BitArray, codec.EncodeError),
) -> Result(Nil, codec.EncodeError)

Send a response through a reply subject. Used by the handler to answer a call.

send

</> 
pub fn send(
  global: GlobalSubject(msg),
  message: msg,
) -> Result(Nil, codec.EncodeError)

Encode and send a message.

subject

</> 
pub fn subject(
  global: GlobalSubject(msg),
) -> process.Subject(BitArray)
✨ Search Document