Struct spaik::Gc

pub struct Gc<T>where
    T: Userdata,{ /* private fields */ }

Thread-safe reference-counted smart-pointer. Cheap to clone. Used to refer to Userdata stored on the SPAIK heap.

Gc<T> survives your VM getting dropped, so you can create a reference to something that you intend for a VM to modify, and then keep the reference after the VM is no longer necessary.

Remember that you have to actually run the VM occasionally for the GC to eventually drop these references. If the Gc<T> has been dropped by your Rust code and your SPAIK code the GC still needs to complete a cycle in order to figure that out.

In order for Gc<T> to be Send/Sync it requires that T is too, it doesn’t do any synchronization magic on T itself.

Implementations

impl<T: Userdata> Gc<T>

pub fn with<R>(&mut self, f: impl Fn(&mut T) -> R) -> R

Why does this take an Fn instead of an FnMut?

Because you should not be able to call with on a potentially aliased Gc<T> inside with recursively, then you could have multiple &mut references to the same data and that is UB in Rust.

You should use with only for simple setter/getter operations on the underlying T and nothing else.

Trait Implementations

impl<T> Clone for Gc<T>where T: Userdata,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Gc<T>where T: Userdata,

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

Formats the value using the given formatter.

impl<T> Display for Gc<T>where T: Display + Userdata,

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

Formats the value using the given formatter.

impl<T: Userdata> Drop for Gc<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> FromLisp<Gc<T>> for PVwhere T: Userdata,

Safety

This is safe for Userdata, because of the additional indirection. They are not stored inline by the GC, the GC only has a pointer to it. This means that unlike other PV ref-types the pointer does not move, and it is therefore sufficient to keep an SPV reference-counter to avoid dangling-pointer references.

fn from_lisp(self, _mem: &mut Arena) -> Result<Gc<T>, Error>

impl<T: ?Sized + Sync + Send + Userdata> Send for Gc<T>

impl<T: ?Sized + Sync + Send + Userdata> Sync for Gc<T>