Struct ModuleId 

pub struct ModuleId(/* private fields */);

Unique identifier for a loadable module.

Convention: Use kebab-case names like “lang-rust”, “feat-completion”.

Static vs Dynamic IDs

Module IDs can be either:

• Static (&'static str): For compile-time known modules, use ModuleId::new()
• Dynamic (String): For runtime-generated modules, use ModuleId::from_string()

Static IDs are preferred for performance (no allocation), but dynamic IDs allow for user-defined or plugin-loaded modules with arbitrary names.

Example

use reovim_kernel::api::v1::ModuleId;

// Static ID (compile-time known)
let static_id = ModuleId::new("lang-rust");

// Dynamic ID (runtime generated)
let name = format!("user-plugin-{}", 42);
let dynamic_id = ModuleId::from_string(name);

// Both work the same way
assert_eq!(static_id.as_str(), "lang-rust");
assert_eq!(dynamic_id.as_str(), "user-plugin-42");

Implementations

impl ModuleId

pub const fn new(id: &'static str) -> Self

Create a new module identifier from a static string.

This is the preferred way to create module IDs for statically-known modules. It’s a const fn and involves no allocation.

pub fn from_string(id: String) -> Self

Create a module identifier from an owned String.

Use this for dynamically-generated module IDs (e.g., user plugins, runtime-loaded modules with user-provided names).

pub fn as_str(&self) -> &str

Get the identifier string.

pub const fn is_static(&self) -> bool

Check if this is a static (borrowed) ID.

pub const fn is_dynamic(&self) -> bool

Check if this is a dynamic (owned) ID.

Trait Implementations

impl Clone for ModuleId

fn clone(&self) -> ModuleId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModuleId

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

Formats the value using the given formatter.

impl Display for ModuleId

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

Formats the value using the given formatter.

impl From<&'static str> for ModuleId

fn from(s: &'static str) -> Self

Converts to this type from the input type.

impl From<String> for ModuleId

fn from(s: String) -> Self

Converts to this type from the input type.

impl Hash for ModuleId

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

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 ModuleId

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

impl StructuralPartialEq for ModuleId