Struct fungi_lang::shared::Shared

pub struct Shared<T> { /* fields omitted */ }

A shared instance of T that serializes once, not once per reference.

Unlike a "bare" Rc, a Shared enjoys the practical property that, when a structure holding multiple (shared) instances of T is serialized, this serialized output holds only one occurrence of a T's serialized representation; the other occurrences merely consist of the T's unique identifier (the serialization of an Id, single machine word on modern machines).

In particular, a shared T has a unique ID permitting table-based indirection, via temporary storage used by serialization and serialization logic; by contrast, a bare Rc lacks this indirection, and thus, it lacks a compact serialized representation for structures with abundant sharing. Generally, abundant sharing via many shared Rc<_>s leads to exponential "blow up" in terms of serialized space and time.

Methods

impl<T: Hash + 'static> Shared<T>

pub fn id(&self) -> Id

pub fn new(t: T) -> Shared<T>

pub fn from_rc(rc: Rc<T>) -> Shared<T>

Trait Implementations

impl<T: Clone> Clone for Shared<T>

fn clone(&self) -> Shared<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: PartialEq + 'static> PartialEq for Shared<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T: PartialEq + 'static> Eq for Shared<T>

impl<T: 'static + Hash> Hash for Shared<T>

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

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

impl<T: Debug> Debug for Shared<T>

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

Formats the value using the given formatter.

impl<T> Deref for Shared<T>

We may deference a (deserialized) Shared just like an Rc; below, rely on the invariant that all deserialized Shared's consist of an Rc (along with a unique ID).

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: Serialize + Hash + 'static> Serialize for Shared<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where     S: Serializer,

Serialize this value into the given Serde serializer.

impl<'de, T: Deserialize<'de> + Hash + 'static> Deserialize<'de> for Shared<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where     D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.