Struct Symbol 

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

A small, copyable handle to a string held by an Interner.

A Symbol is a newtype over a 32-bit id, so it is four bytes, Copy, and as cheap to pass or store as an integer. The point of interning is that a name in an AST node or a symbol-table key costs a Symbol instead of an owned String, and comparing two names becomes an integer comparison instead of a byte-by-byte walk — ==, Ord, and Hash on a Symbol never touch the underlying bytes.

A Symbol is only meaningful together with the interner that issued it. Two symbols from the same interner are equal exactly when they name the same string; symbols from different interners share no relationship and should not be compared or resolved across interners (resolving a foreign symbol is handled safely — see Interner::resolve — but the result is not meaningful).

Examples

use intern_lang::Interner;

let mut interner = Interner::new();
let a = interner.intern("loop");
let b = interner.intern("loop");

// Same string interns to the same symbol, so equality is an integer compare.
assert_eq!(a, b);

// A symbol is `Copy`: handing it around never moves or clones a string.
let copy = a;
assert_eq!(copy, a);

Implementations

impl Symbol

pub fn as_u32(self) -> u32

Returns the raw 1-based integer id backing this symbol.

The id is stable for the lifetime of the issuing interner and is assigned in interning order: the first distinct string interned gets 1, the second 2, and so on. It is exposed for diagnostics, stable ordering, and building external side tables keyed by symbol; it is not a string and carries no meaning outside the interner that produced it.

Examples

use intern_lang::Interner;

let mut interner = Interner::new();
let first = interner.intern("alpha");
let second = interner.intern("beta");

assert_eq!(first.as_u32(), 1);
assert_eq!(second.as_u32(), 2);
// Re-interning an existing string returns the same id, never a new one.
assert_eq!(interner.intern("alpha").as_u32(), 1);

Trait Implementations

impl Clone for Symbol

fn clone(&self) -> Symbol

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Symbol

impl Debug for Symbol

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

Formats the value using the given formatter.

impl Eq for Symbol

impl Hash for Symbol

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 Ord for Symbol

fn cmp(&self, other: &Symbol) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Symbol

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

fn partial_cmp(&self, other: &Symbol) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Symbol