Struct Moo 

pub struct Moo<T> { /* private fields */ }

A clone-on-write, reference counted pointer to an AST type.

Cloning values of this type will not clone the underlying value until it is modified, e.g., with Moo::make_mut.

Unlike Rc and Arc, trait implementations on this type do not need to preserve shared ownership - that is, two pointers that used to point to the same value may not do so after calling a trait method on them. In particular, calling Uniplate methods may cause a clone-on-write to occur.

Note: like BoxandRc, methods on Mooare all associated functions, which means you have to call them as, e.g.Moo::make_mut(&value)instead ofvalue.make_mut(). This is so that there are no conflicts with the inner type T`, which this type dereferences to.

Implementations

impl<T> Moo<T>

pub fn new(value: T) -> Moo<T>

Constructs a new Moo<T>.

impl<T> Moo<T>

where T: Clone,

pub fn make_mut(this: &mut Moo<T>) -> &mut T

Makes a mutable reference into the given Moo.

If there are other Moo pointers to the same allocation, then make_mut will clone the inner value to a new allocation to ensure unique ownership. This is also referred to as clone-on-write.

pub fn unwrap_or_clone(this: Moo<T>) -> T

If we have the only reference to T then unwrap it. Otherwise, clone T and return the clone.

Assuming moo_t is of type Moo<T>, this function is functionally equivalent to (*moo_t).clone(), but will avoid cloning the inner value where possible.

Trait Implementations

impl<T> AsRef<T> for Moo<T>

fn as_ref(&self) -> &T

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

impl<To, U> Biplate<To> for Moo<U>

where To: Uniplate, U: Uniplate + Biplate<To>,

fn biplate(&self) -> (Tree<To>, Box<dyn Fn(Tree<To>) -> Moo<U>>)

Definition of a Biplate.

fn with_children_bi(&self, children: VecDeque<To>) -> Self

Reconstructs the node with the given children.

fn descend_bi(&self, op: &impl Fn(To) -> To) -> Self

Biplate variant of [Uniplate::descend]

fn universe_bi(&self) -> VecDeque<To>

Gets all children of a node, including itself and all children.

fn children_bi(&self) -> VecDeque<To>

Returns the children of a type. If to == from then it returns the original element (in contrast to children).

fn transform_bi(&self, op: &impl Fn(To) -> To) -> Self

Applies the given function to all nodes bottom up.

fn holes_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts_bi(&self) -> impl Iterator<Item = (To, impl Fn(To))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl<T> Clone for Moo<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Moo<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Moo<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<Moo<T> as Deref>::Target

Dereferences the value.

impl<'de, T> Deserialize<'de> for Moo<T>

where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<Moo<T>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for Moo<T>

where T: Display,

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

Formats the value using the given formatter.

impl From<Moo<Expression>> for Expression

fn from(val: Moo<Expression>) -> Expression

Converts to this type from the input type.

impl<T> PartialEq for Moo<T>

where T: PartialEq,

fn eq(&self, other: &Moo<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<T> Serialize for Moo<T>

where T: Serialize,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> TryFrom<&'a Moo<Expression>> for &'a Atom

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from( value: &'a Moo<Expression>, ) -> Result<&'a Atom, <&'a Atom as TryFrom<&'a Moo<Expression>>>::Error>

Performs the conversion.

impl TryFrom<Moo<Expression>> for Atom

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from( value: Moo<Expression>, ) -> Result<Atom, <Atom as TryFrom<Moo<Expression>>>::Error>

Performs the conversion.

impl<T> Uniplate for Moo<T>

where T: Uniplate,

fn uniplate(&self) -> (Tree<Moo<T>>, Box<dyn Fn(Tree<Moo<T>>) -> Moo<T>>)

Definition of a Uniplate.

fn descend(&self, op: &impl Fn(Self) -> Self) -> Self

Applies a function to all direct children of this

fn universe(&self) -> VecDeque<Self>

Gets all children of a node, including itself and all children.

fn children(&self) -> VecDeque<Self>

Gets the direct children (maximal substructures) of a node.

fn with_children(&self, children: VecDeque<Self>) -> Self

Reconstructs the node with the given children.

fn transform(&self, f: &impl Fn(Self) -> Self) -> Self

Applies the given function to all nodes bottom up.

fn rewrite(&self, f: &impl Fn(Self) -> Option<Self>) -> Self

Rewrites by applying a rule everywhere it can.

fn cata<T>(&self, op: &impl Fn(Self, VecDeque<T>) -> T) -> T

Performs a fold-like computation on each value.

fn holes(&self) -> impl Iterator<Item = (Self, impl Fn(Self))>

Returns an iterator over all direct children of the input, paired with a function that “fills the hole” where the child was with a new value.

fn contexts(&self) -> impl Iterator<Item = (Self, impl Fn(Self))>

Returns an iterator over the universe of the input, paired with a function that “fills the hole” where the child was with a new value.

impl<T> Eq for Moo<T>

where T: Eq,

impl<T> StructuralPartialEq for Moo<T>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes