Struct merge_rs::mergeable::Mergable

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

Very often, types from the standard library and other crates will not implement the Merge or MergeMut traits, preventing us from leveraging recursive merging with complex data structures. Given that rust only allows trait implementations in the crate defining the trait or the struct, this puts users in a tough position of writing more code.

The Mergable type is a type wrapper that implements the Merge and MergeMut traits using the provided [Strategy] while exposing the underlying type through Deref and a number of operators that forward the underlying implementation to the inner type.

Usage

use merge_rs::Merge;
use merge_rs::mergeable::Mergable;
 
struct Message(String);
impl Message {
  pub fn new(msg: String) -> Self {
    Self(msg)
  }
 
  pub fn get(&self) -> &str {
    &self.0
  }
}
 
fn concat_messages(
  left: &Message, 
  right: &Message
) -> Message {
  Message::new(
    format!("{} {}", left.get(), right.get())
  )
}
 
let msg1 = Mergable::new(
    Message::new("hello".to_string()),
    concat_messages
);
let msg2 = Mergable::new(
    Message::new("world".to_string()),
    concat_messages
);
let greeting = msg1.merge(&msg2);
 
let hello_sring = msg1.get();

Implementations

impl<T> Mergable<T>

pub fn new(inner: T, strategy: fn(_: &T, _: &T) -> T) -> Self

Construct a new Mergable type with a given inner type and strategy for merging instances of the inner types together.

Trait Implementations

impl<T: Add<Output = T>> Add<Mergable<T>> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T: Add<Output = T>> Add<T> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self

Performs the + operation.

impl<T> AddAssign<Mergable<T>> for Mergable<T>where
    T: AddAssign,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T> AddAssign<T> for Mergable<T>where
    T: AddAssign,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: BitAnd<Output = T>> BitAnd<Mergable<T>> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self

Performs the & operation.

impl<T: BitAnd<Output = T>> BitAnd<T> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self

Performs the & operation.

impl<T: BitAndAssign> BitAndAssign<Mergable<T>> for Mergable<T>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T: BitAndAssign> BitAndAssign<T> for Mergable<T>

fn bitand_assign(&mut self, rhs: T)

Performs the &= operation.

impl<T: BitOr<Output = T>> BitOr<Mergable<T>> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self

Performs the | operation.

impl<T: BitOr<Output = T>> BitOr<T> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self

Performs the | operation.

impl<T: BitOrAssign> BitOrAssign<Mergable<T>> for Mergable<T>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T: BitOrAssign> BitOrAssign<T> for Mergable<T>

fn bitor_assign(&mut self, rhs: T)

Performs the |= operation.

impl<T: BitXor<Output = T>> BitXor<Mergable<T>> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self

Performs the ^ operation.

impl<T: BitXor<Output = T>> BitXor<T> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self

Performs the ^ operation.

impl<T: BitXorAssign> BitXorAssign<Mergable<T>> for Mergable<T>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T: BitXorAssign> BitXorAssign<T> for Mergable<T>

fn bitxor_assign(&mut self, rhs: T)

Performs the ^= operation.

impl<T> Clone for Mergable<T>where
    T: Clone,

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 Mergable<T>where
    T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for Mergable<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Mergable<T>

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

Mutably dereferences the value.

impl<T: Div<Output = T>> Div<Mergable<T>> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs the / operation.

impl<T: Div<Output = T>> Div<T> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self

Performs the / operation.

impl<T> DivAssign<Mergable<T>> for Mergable<T>where
    T: DivAssign,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T> DivAssign<T> for Mergable<T>where
    T: DivAssign,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T> Merge for Mergable<T>

fn merge(&self, other: &Self) -> Self

impl<T> MergeMut for Mergable<T>

fn merge_mut(&mut self, other: &Self)

impl<T: Mul<Output = T>> Mul<Mergable<T>> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl<T: Mul<Output = T>> Mul<T> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self

Performs the * operation.

impl<T> MulAssign<Mergable<T>> for Mergable<T>where
    T: MulAssign,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T> MulAssign<T> for Mergable<T>where
    T: MulAssign,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T> Neg for Mergable<T>where
    T: Neg<Output = T>,

type Output = Mergable<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: Not<Output = T>> Not for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl<T: Rem<Output = T>> Rem<Mergable<T>> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self

Performs the % operation.

impl<T: Rem<Output = T>> Rem<T> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self

Performs the % operation.

impl<T> RemAssign<Mergable<T>> for Mergable<T>where
    T: RemAssign,

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<T> RemAssign<T> for Mergable<T>where
    T: RemAssign,

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl<T: Shl<Output = T>> Shl<Mergable<T>> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self

Performs the << operation.

impl<T: Shl<Output = T>> Shl<T> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the << operator.

fn shl(self, rhs: T) -> Self

Performs the << operation.

impl<T: ShlAssign> ShlAssign<Mergable<T>> for Mergable<T>

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<T: ShlAssign> ShlAssign<T> for Mergable<T>

fn shl_assign(&mut self, rhs: T)

Performs the <<= operation.

impl<T: Shr<Output = T>> Shr<Mergable<T>> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self

Performs the >> operation.

impl<T: Shr<Output = T>> Shr<T> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the >> operator.

fn shr(self, rhs: T) -> Self

Performs the >> operation.

impl<T: ShrAssign> ShrAssign<Mergable<T>> for Mergable<T>

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<T: ShrAssign> ShrAssign<T> for Mergable<T>

fn shr_assign(&mut self, rhs: T)

Performs the >>= operation.

impl<T: Sub<Output = T>> Sub<Mergable<T>> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<T: Sub<Output = T>> Sub<T> for Mergable<T>

type Output = Mergable<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self

Performs the - operation.

impl<T> SubAssign<Mergable<T>> for Mergable<T>where
    T: SubAssign,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T> SubAssign<T> for Mergable<T>where
    T: SubAssign,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.