Struct Pid 

pub struct Pid { /* private fields */ }

A process identifier.

Every process in Starlang has a unique Pid that can be used to send messages, establish links, create monitors, and query process status.

The node is stored as an Atom (interned string) for global uniqueness. Display format matches Erlang’s <node.id.creation> convention, showing <0.id.creation> for local PIDs and <N.id.creation> for remote ones.

Examples

use starlang_core::Pid;

let pid = Pid::new();
println!("Process: {}", pid);  // e.g., "<0.42.0>"

// Pids can be compared
let pid2 = Pid::new();
assert_ne!(pid, pid2);

Implementations

impl Pid

pub fn new() -> Pid

Creates a new unique process identifier on the local node.

Each call to new() returns a globally unique Pid. The node is set to the current node’s name atom.

Examples

use starlang_core::Pid;

let pid1 = Pid::new();
let pid2 = Pid::new();
assert_ne!(pid1, pid2);

pub fn from_parts_atom(node: Atom, id: u64, creation: u32) -> Pid

Creates a Pid with a specific node atom, id, and creation values.

This is primarily used for deserialization and testing. In normal usage, prefer Pid::new().

pub fn remote(node_name: &str, id: u64, creation: u32) -> Pid

Creates a remote Pid for a process on another node.

This is used when receiving PIDs from remote nodes during distribution.

Examples

use starlang_core::Pid;
use starlang_atom::atom;

let remote_pid = Pid::remote("node2@localhost", 100, 5);
assert!(!remote_pid.is_local());

pub fn node(&self) -> Atom

Returns the node atom.

pub fn node_name(&self) -> String

Returns the node name as a string.

pub const fn id(&self) -> u64

Returns the process identifier within the node.

pub const fn creation(&self) -> u32

Returns the creation number.

The creation number distinguishes PIDs across node restarts.

pub fn is_local(&self) -> bool

Returns true if this is a local process.

A PID is local if its node matches the current node’s name.

Trait Implementations

impl Clone for Pid

fn clone(&self) -> Pid

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Pid

impl Debug for Pid

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Pid

fn default() -> Pid

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Pid

fn deserialize<__D>( __deserializer: __D, ) -> Result<Pid, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Pid

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for Pid

impl Hash for Pid

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Pid

fn eq(&self, other: &Pid) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Pid

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Pid