Struct Role 

pub struct Role { /* private fields */ }

A role (participant) in the choreography

Roles represent the different participants in a distributed protocol. They can be simple (e.g., Client, Server) or parameterized (e.g., Worker[0], Worker[N] where the parameter can be a constant or variable).

Examples

use quote::format_ident;
use telltale_runtime::{Role, RoleParam};

// Simple role
let client = Role::new(format_ident!("Client")).unwrap();

// Static parameterized role
let worker = Role::with_param(format_ident!("Worker"), RoleParam::Static(3)).unwrap();

// Dynamic role
let dynamic_worker = Role::with_param(format_ident!("Worker"), RoleParam::Runtime).unwrap();

Implementations

impl Role

pub fn new(name: Ident) -> Result<Role, RoleValidationError>

Create a new simple role with the given name

pub fn with_param( name: Ident, param: RoleParam, ) -> Result<Role, RoleValidationError>

Create a role with a parameter (e.g., Worker[3], Worker[N], Worker[*])

pub fn with_index( name: Ident, index: RoleIndex, ) -> Result<Role, RoleValidationError>

Create a role reference with an index (e.g., Worker[0], Worker[i], Worker[*])

pub fn with_param_and_index( name: Ident, param: RoleParam, index: RoleIndex, ) -> Result<Role, RoleValidationError>

Create a role reference with both param and index

pub fn indexed(name: Ident, index: usize) -> Result<Role, RoleValidationError>

Create a new indexed role (e.g., Worker with index 0)

pub fn parameterized( name: Ident, param: TokenStream, ) -> Result<Role, RoleValidationError>

Create a parameterized role with symbolic parameter (e.g., Worker[N])

pub fn array(name: Ident, size: usize) -> Result<Role, RoleValidationError>

Create a role array with a concrete size (e.g., Worker[3])

pub fn name(&self) -> &Ident

Get the role name identifier.

pub fn param(&self) -> Option<&RoleParam>

Get the role parameter if it exists.

pub fn index(&self) -> Option<&RoleIndex>

Get the role index if it exists.

pub fn array_size(&self) -> Option<&TokenStream>

Get the array size token if it exists.

pub fn is_indexed(&self) -> bool

Check if this role has an index

pub fn to_ident(&self) -> Ident

Generate a Rust identifier for this role

pub fn is_parameterized(&self) -> bool

Check if this role is parameterized (has either index or param)

pub fn is_array(&self) -> bool

Check if this is a role array (declared with size like Worker[N])

pub fn is_dynamic(&self) -> bool

Check if this role has dynamic parameterization (runtime count)

pub fn is_symbolic(&self) -> bool

Check if this role has symbolic parameterization

pub fn is_wildcard(&self) -> bool

Check if this role reference uses a wildcard index

pub fn is_range(&self) -> bool

Check if this role reference uses a range index

pub fn get_param(&self) -> Option<&RoleParam>

Get the role parameter if it exists

pub fn get_index(&self) -> Option<&RoleIndex>

Get the role index if it exists

pub fn get_static_count(&self) -> Option<u32>

Get the static count for static parameterized roles

pub fn get_symbolic_name(&self) -> Option<&str>

Get the symbolic name for symbolic parameterized roles

pub fn matches_family(&self, family: &Role) -> bool

Check if this role instance matches the given role family

For parameterized roles, this checks if the base name matches, ignoring specific indices. For example:

• Worker[0] matches Worker[N]
• Worker[i] matches Worker[N]
• Worker[1] matches Worker[3] (if Worker[3] is the array declaration)
• Client only matches Client (exact match for non-parameterized)

pub fn validate(&self) -> Result<(), RoleValidationError>

Validate this role for security and safety constraints

pub fn safe_static(name: Ident, count: u32) -> Result<Role, RoleValidationError>

Create a safe static role with overflow checking

pub fn safe_indexed( name: Ident, index: u32, ) -> Result<Role, RoleValidationError>

Create a safe indexed role with overflow checking

pub fn safe_range( name: Ident, start: u32, end: u32, ) -> Result<Role, RoleValidationError>

Create a safe range role with overflow checking

Trait Implementations

impl Clone for Role

fn clone(&self) -> Role

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Role

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

Formats the value using the given formatter.

impl Hash for Role

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 Role

fn eq(&self, other: &Role) -> 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 Eq for Role