Struct Rt 

#[repr(transparent)]
pub struct Rt<T: ?Sized> {
    _aliasable: PhantomPinned,
    inner: T,
}

A “Root Tracable” type. If a type is wrapped in Rt, it is known to be rooted and hold items past garbage collection. This type is never used as an owned type, only a reference. This ensures that underlying data does not move. In order to access the inner data, use Rt::bind_ref or Rt::bind_mut methods.

Fields

_aliasable: PhantomPinned

inner: T

Implementations

impl<T> Rt<T>

fn inner(&self) -> &T

fn inner_mut(&mut self) -> &mut T

fn inner_ptr(&self) -> *const T

fn inner_mut_ptr(&mut self) -> *mut T

pub(crate) fn bind_ref<'a, 'ob>( &'a self, _: &'ob Context<'_>, ) -> &'a <T as WithLifetime<'ob>>::Out

where T: WithLifetime<'ob>,

pub(crate) fn bind_mut<'a, 'ob>( &'a mut self, _: &'ob Context<'_>, ) -> &'a mut <T as WithLifetime<'ob>>::Out

where T: WithLifetime<'ob>,

pub(crate) fn set<U: IntoRoot<T>>(&mut self, item: U)

impl<T> Rt<Slot<T>>

pub(crate) fn bind<'ob>( &self, _: &'ob Context<'_>, ) -> <T as WithLifetime<'ob>>::Out

where T: WithLifetime<'ob> + Copy,

pub(crate) unsafe fn bind_unchecked<'ob>( &'ob self, ) -> <T as WithLifetime<'ob>>::Out

where T: WithLifetime<'ob> + Copy,

pub(crate) fn get_inner(&self) -> T

where T: Copy,

Get a copy of the inner value without requiring a Context. This is useful when you need to access the value but don’t have a Context available.

pub(crate) fn bind_slice<'brw, 'ob, U>( slice: &'brw [Rt<Slot<Gc<T>>>], _: &'ob Context<'_>, ) -> &'brw [Gc<U>]

where Gc<T>: WithLifetime<'ob, Out = Gc<U>>, Gc<U>: 'ob,

impl<T> Rt<Slot<Gc<T>>>

pub(crate) fn untag<'ob, U>(&self, cx: &'ob Context<'_>) -> U

where Gc<T>: WithLifetime<'ob, Out = Gc<U>> + Copy, Gc<U>: Untag<U>,

Calls untag on the tagged Gc pointer

pub(crate) fn try_as<U, E>(&self) -> Result<&Rt<Slot<Gc<U>>>, E>

where Gc<T>: TryInto<Gc<U>, Error = E> + Copy,

Like try_into, but needed to due no specialization

impl<T> Rt<Slot<Gc<T>>>

pub(crate) fn bind_as<'ob, U, E>(&self, _cx: &'ob Context<'_>) -> Result<U, E>

where Gc<T>: WithLifetime<'ob> + Copy, <Gc<T> as WithLifetime<'ob>>::Out: TryInto<U, Error = E> + Copy,

Like try_into().bind(cx), but needed to due no specialization

pub(crate) fn cast<U>(&self) -> &Rt<Slot<Gc<U>>>

where Gc<T>: Into<Gc<U>> + Copy,

Like Into, but needed to due no specialization

pub(crate) fn as_cons(&self) -> &Rt<Slot<Gc<&Cons>>>

impl<'a> Rt<Slot<Gc<ObjectType<'a>>>>

pub(crate) fn try_as_option<T, E>(&self) -> Result<Option<&Rt<Slot<Gc<T>>>>, E>

where Gc<ObjectType<'a>>: TryInto<Gc<T>, Error = E>,

impl Rt<Slot<&Cons>>

pub(crate) fn car<'ob>(&self, cx: &'ob Context<'_>) -> Gc<ObjectType<'ob>>

pub(crate) fn cdr<'ob>(&self, cx: &'ob Context<'_>) -> Gc<ObjectType<'ob>>

impl<T> Rt<Vec<T>>

fn as_mut_ref(&mut self) -> &mut Vec<Rt<T>>

pub(crate) fn push<U: IntoRoot<T>>(&mut self, item: U)

pub(crate) fn truncate(&mut self, len: usize)

pub(crate) fn pop(&mut self)

pub(crate) fn swap_remove(&mut self, index: usize)

pub(crate) fn reserve(&mut self, additional: usize)

pub(crate) fn capacity(&self) -> usize

impl<T> Rt<Vec<T>>

pub(crate) fn extend_from_slice<U: IntoRoot<T> + Copy>(&mut self, src: &[U])

impl<T: Clone> Rt<Vec<T>>

pub(crate) fn extend_from_within(&mut self, src: impl RangeBounds<usize>)

impl<K, V> Rt<ObjectMap<K, V>>

where K: Eq + Hash,

fn as_ref(&self) -> &IndexMap<K, V>

fn as_mut(&mut self) -> &mut IndexMap<K, V>

pub(crate) fn insert<Kx: IntoRoot<K>, Vx: IntoRoot<V>>(&mut self, k: Kx, v: Vx)

pub(crate) fn get<Q: IntoRoot<K>>(&self, k: Q) -> Option<&Rt<V>>

pub(crate) fn get_mut<Q: IntoRoot<K>>(&mut self, k: Q) -> Option<&mut Rt<V>>

pub(crate) fn remove<Q: IntoRoot<K>>(&mut self, k: Q)

impl Rt<Slot<Gc<FunctionType<'_>>>>

pub(crate) fn call<'ob>( &self, frame: &mut CallFrame<'_, '_>, name: Option<&str>, cx: &'ob mut Context<'_>, ) -> Result<Gc<ObjectType<'ob>>, EvalError>

Trait Implementations

impl<T, const N: usize> AsRef<[Rt<T>]> for Rt<[T; N]>

fn as_ref(&self) -> &[Rt<T>]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Debug> Debug for Rt<T>

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

Formats the value using the given formatter.

impl<T, U> Deref for Rt<(T, U)>

type Target = (Rt<T>, Rt<U>)

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> Deref for Rt<Option<T>>

type Target = Option<Rt<T>>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: RootedDeref> Deref for Rt<T>

type Target = <T as RootedDeref>::Target

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> Deref for Rt<Vec<T>>

type Target = [Rt<T>]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, U> DerefMut for Rt<(T, U)>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: RootedDeref> DerefMut for Rt<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> DerefMut for Rt<Vec<T>>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Display> Display for Rt<T>

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

Formats the value using the given formatter.

impl From<&Rt<Slot<Gc<ObjectType<'_>>>>> for Option<()>

fn from(value: &Rt<Slot<Gc<ObjectType<'_>>>>) -> Self

Converts to this type from the input type.

impl<T> Hash for Rt<T>

where T: Hash,

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<T, I, const N: usize> Index<I> for Rt<[T; N]>

where [Rt<T>]: Index<I>,

type Output = <[Rt<T>] as Index<I>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, I: SliceIndex<[Rt<T>]>> Index<I> for Rt<Vec<T>>

type Output = <I as SliceIndex<[Rt<T>]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, I, const N: usize> IndexMut<I> for Rt<[T; N]>

where [Rt<T>]: IndexMut<I>,

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T, I: SliceIndex<[Rt<T>]>> IndexMut<I> for Rt<Vec<T>>

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IntoObject for &Rt<Slot<Gc<ObjectType<'_>>>>

type Out<'ob> = ObjectType<'ob>

fn into_obj<const C: bool>(self, _block: &Block<C>) -> Gc<Self::Out<'_>>

impl IntoObject for &mut Rt<Slot<Gc<ObjectType<'_>>>>

type Out<'ob> = ObjectType<'ob>

fn into_obj<const C: bool>(self, _block: &Block<C>) -> Gc<Self::Out<'_>>

impl<'a, T, U> IntoRoot<Slot<U>> for &Rt<Slot<T>>

where T: WithLifetime<'a, Out = U> + Copy,

unsafe fn into_root(self) -> Slot<U>

impl<T, U> PartialEq<U> for Rt<Slot<T>>

where Slot<T>: PartialEq<U>,

fn eq(&self, other: &U) -> 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<T: PartialEq + ?Sized> PartialEq for Rt<T>

fn eq(&self, other: &Rt<T>) -> 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 TryFrom<&Rt<Slot<Gc<ObjectType<'_>>>>> for usize

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &Rt<Slot<Gc<ObjectType<'_>>>>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Eq + ?Sized> Eq for Rt<T>

impl<T: ?Sized> StructuralPartialEq for Rt<T>