Struct Symbol

pub(crate) struct Symbol<'a> {
    data: *const u8,
    marker: PhantomData<&'a SymbolCell>,
}

Fields

data: *const u8

marker: PhantomData<&'a SymbolCell>

Implementations

impl<'a> Symbol<'a>

pub(crate) fn get(self) -> &'a SymbolCell

pub(in core) fn as_ptr( self, ) -> *const u8

pub(in core) unsafe fn from_offset_ptr( ptr: *const u8, ) -> Self

pub(in core) unsafe fn from_ptr( ptr: *const SymbolCell, ) -> Self

pub(in core) const fn new_builtin( idx: usize, ) -> Self

pub(crate) fn make_special(self)

pub(crate) fn is_special(self) -> bool

impl<'new> Symbol<'_>

pub(in core) fn clone_in<const C: bool>( self, bk: &'new Block<C>, ) -> Gc<Symbol<'new>>

impl<'ob> Symbol<'ob>

pub(in core) fn new( name: &'static str, block: &'ob Block<true>, ) -> Self

pub(crate) fn new_uninterned<const C: bool>( name: &str, block: &'ob Block<C>, ) -> Self

Methods from Deref<Target = SymbolCell>

const NULL: *mut u8 = {0x0 as *mut u8}

const EMTPTY: AtomicPtr<u8>

pub(crate) fn as_bytes(&self) -> &[u8]

pub(crate) fn name(&self) -> &str

pub(crate) fn interned(&self) -> bool

pub(crate) fn is_const(&self) -> bool

Check if the symbol is constant like nil, t, or :keyword

pub(crate) fn has_func(&self) -> bool

fn get(&self) -> Option<Gc<FunctionType<'_>>>

pub(crate) fn func<'a>( &self, _cx: &'a Context<'_>, ) -> Option<Gc<FunctionType<'a>>>

pub(crate) fn follow_indirect<'ob>( &self, cx: &'ob Context<'_>, ) -> Option<Gc<FunctionType<'ob>>>

Follow the chain of symbols to find the function at the end, if any.

pub(in core) unsafe fn set_func( &self, func: Gc<FunctionType<'_>>, ) -> Result<()>

Set the function for this symbol. This function is unsafe to call and requires that the caller:

1. Has marked the entire function as read only
2. Has cloned the function into the SymbolMap block
3. Ensured the symbol is not constant

pub(crate) fn unbind_func(&self)

Trait Implementations

impl<'a> Clone for Symbol<'a>

fn clone(&self) -> Symbol<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Symbol<'_>

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

Formats the value using the given formatter.

impl Deref for Symbol<'_>

type Target = SymbolCell

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for Symbol<'_>

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

Formats the value using the given formatter.

impl<'ob> From<Symbol<'_>> for Gc<ObjectType<'ob>>

fn from(x: Symbol<'_>) -> Self

Converts to this type from the input type.

impl<'ob> From<Symbol<'ob>> for Gc<FunctionType<'ob>>

fn from(x: Symbol<'ob>) -> Self

Converts to this type from the input type.

impl<'a> GcMoveable for Symbol<'a>

type Value = Symbol<'a>

fn move_value(&self, to_space: &Bump) -> Option<(Self::Value, bool)>

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 PartialEq<Symbol<'_>> for Gc<ObjectType<'_>>

fn eq(&self, other: &Symbol<'_>) -> bool

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

const 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<'a> PartialEq for Symbol<'a>

fn eq(&self, other: &Symbol<'a>) -> bool

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

const 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 TaggedPtr for Symbol<'_>

const TAG: Tag = Tag::Symbol

Tag value. This is only applicable to base values. Use Int for sum types.

type Ptr = u8

The type of object being pointed to. This will be different for all implementors.

unsafe fn tag_ptr(ptr: *const Self::Ptr) -> Gc<Self>

Given a pointer to Ptr return a Tagged pointer.

unsafe fn from_obj_ptr(ptr: *const u8) -> Self

Given an untyped pointer, reinterpret to self.

fn get_ptr(self) -> *const Self::Ptr

Get the underlying pointer.

fn untag(val: Gc<Self>) -> Self

Remove the tag from the Gc<T> and return the inner type. If it is base type then it will only have a single possible value and can be untagged without checks, but sum types need to create all values they can hold. We use tagged base types to let us reinterpret bits without actually modify them.

fn tag(self) -> Gc<Self>

Given the type, return a tagged version of it. When using a sum type or an immediate value like i64, we override this method to set the proper tag.

impl TracePtr for Symbol<'_>

fn trace_ptr(&self, state: &mut GcState)

impl<'ob> TryFrom<Gc<ObjectType<'ob>>> for Symbol<'ob>

type Error = TypeError

The type returned in the event of a conversion error.

fn try_from(obj: Gc<ObjectType<'ob>>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'new> WithLifetime<'new> for Symbol<'_>

type Out = Symbol<'new>

unsafe fn with_lifetime(self) -> Self::Out

impl<'a> Copy for Symbol<'a>

impl<'a> Eq for Symbol<'a>

impl GcPtr for Symbol<'_>

impl Send for Symbol<'_>

impl<'a> StructuralPartialEq for Symbol<'a>